@tangle-network/agent-eval 0.172.1 → 0.173.0

package/dist/semantic-concept-judge-Ct3QU7t5.js

@@ -0,0 +1,780 @@
+import { i as CostLedger } from "./cost-ledger-B1qx30B4.js";
+import { l as Mutex } from "./ledger-core-PIfjCbKn.js";
+import { j as RawAnalystFindingSchema } from "./kind-factory-gP6lDySe.js";
+import { c as extractJsonPayload } from "./llm-client-CxQtdtd6.js";
+import { n as paidJsonChat, t as paidChat } from "./chat-json-call-C26igCih.js";
+import { n as decodeRawFindingArray } from "./dspy-rlm-engine-D5byiHn9.js";
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from "node:fs";
+import { z } from "zod";
+import { dirname } from "node:path";
+//#region src/analyst/chat-trace-engine.ts
+/**
+* A `TraceAnalysisEngine` that runs entirely inside Node against a
+* caller-owned `ChatClient`.
+*
+* The other engine in this package, `createDspyRlmTraceEngine`, reaches the
+* DSPy RLM through a Python subprocess. That made every model-backed analyst
+* unreachable for a consumer that already owns a model seam and no Python:
+* `createTraceAnalyst` requires an engine, the only exported constructor
+* required a Python runner, so `buildDefaultAnalystRegistry()` registered the
+* deterministic analyst alone and `analystsFromRegistry` refused the result.
+*
+* This engine closes that path. It drives the same investigation contract —
+* bounded trace tools, a prose answer, a strict findings array — with native
+* function calls over the transport the caller already bound with
+* `createChatClient`. A caller holding a bare
+* `(request: LlmCallRequest) => Promise<LlmCallResult>` adapts it in one line:
+*
+*   createChatClient({ transport: 'custom', chat: call, defaultModel, maximumAttempts })
+*
+* agent-eval still executes no paid model and holds no provider credential.
+* Every call goes through `paidChat`, so the shared cost ledger reserves the
+* priced maximum before the call and settles the receipt after it.
+*
+* Shape of one investigation:
+*   1. Investigation turns. The model reads the trace store through the tools
+*      its analyst kind was given. A turn that requests no tool ends the
+*      phase; an exhausted iteration or tool budget also ends it.
+*   2. One report turn. The model returns `{ answer, findings }` as JSON,
+*      decoded by the same `decodeRawFindingArray` the Python bridge uses, so
+*      a row this engine accepts is a row that engine could report.
+*/
+/** Bumped whenever this engine's execution behavior changes. */
+const CHAT_TRACE_ENGINE_VERSION = "1.0.0";
+const ENGINE_ID = "chat-trace";
+/** Marker appended to a tool result cut down to the retained-output budget. */
+const TRUNCATION_MARKER = "\n…[truncated to the analyst maxOutputChars budget]";
+/**
+* The report envelope. Its `findings` rows are generated from
+* `RawAnalystFindingSchema`, so the schema offered to a provider and the
+* decoder that accepts the answer cannot drift apart.
+*/
+function buildReportJsonSchema() {
+	const row = z.toJSONSchema(RawAnalystFindingSchema, { target: "draft-7" });
+	delete row.$schema;
+	return {
+		name: "trace_analysis_report",
+		schema: {
+			type: "object",
+			additionalProperties: false,
+			required: ["answer", "findings"],
+			properties: {
+				answer: {
+					type: "string",
+					description: "Direct prose answer to the question."
+				},
+				findings: {
+					type: "array",
+					items: row
+				}
+			}
+		}
+	};
+}
+const REPORT_JSON_SCHEMA = buildReportJsonSchema();
+/**
+* Run bounded recursive trace analysis in-process over a caller-owned chat
+* transport. No Python, no subprocess, no loopback proxy.
+*/
+function createChatTraceEngine(options) {
+	const model = resolveModel(options);
+	const maxOutputTokens = options.maxOutputTokens ?? 16384;
+	if (!Number.isSafeInteger(maxOutputTokens) || maxOutputTokens <= 0) throw new TypeError("chat trace engine maxOutputTokens must be a positive safe integer");
+	if (options.temperature !== void 0 && (!Number.isFinite(options.temperature) || options.temperature < 0)) throw new TypeError("chat trace engine temperature must be a non-negative finite number");
+	if (options.requestTimeoutMs !== void 0 && (!Number.isSafeInteger(options.requestTimeoutMs) || options.requestTimeoutMs <= 0)) throw new TypeError("chat trace engine requestTimeoutMs must be a positive safe integer");
+	const reportFormat = options.reportFormat ?? "json-object";
+	if (reportFormat !== "json-object" && reportFormat !== "json-schema") throw new TypeError(`chat trace engine reportFormat must be json-object or json-schema`);
+	return {
+		id: ENGINE_ID,
+		description: "In-process recursive trace analysis over a caller-owned ChatClient with native tool calls.",
+		model,
+		version: CHAT_TRACE_ENGINE_VERSION,
+		executionConfig: {
+			kind: ENGINE_ID,
+			model,
+			transport: options.chat.transport,
+			maximum_attempts: options.chat.maximumAttempts ?? null,
+			pricing: options.pricing ? { ...options.pricing } : null,
+			max_output_tokens: maxOutputTokens,
+			temperature: options.temperature ?? null,
+			thinking: options.thinking ?? null,
+			request_timeout_ms: options.requestTimeoutMs ?? null,
+			report_format: reportFormat,
+			report_schema_name: REPORT_JSON_SCHEMA.name
+		},
+		analyze: (request) => analyze(request, {
+			...options,
+			model,
+			maxOutputTokens,
+			reportFormat
+		})
+	};
+}
+async function analyze(request, options) {
+	if (request.limits.maxLlmCalls < 2) throw new Error(`chat trace engine reserves one model call for the report, so maxLlmCalls must be at least 2 (analyst '${request.analystId}' declared ${request.limits.maxLlmCalls})`);
+	const toolsByName = new Map(request.tools.map((tool) => [tool.name, tool]));
+	if (toolsByName.size !== request.tools.length) throw new Error(`chat trace engine received duplicate tool names for '${request.analystId}'`);
+	const toolDefinitions = request.tools.map((tool) => ({
+		type: "function",
+		function: {
+			name: tool.name,
+			description: tool.description,
+			parameters: tool.parameters
+		}
+	}));
+	const investigationTurns = Math.max(1, Math.min(request.limits.maxIterations, request.limits.maxLlmCalls - 1));
+	const messages = [{
+		role: "system",
+		content: systemPrompt(request, investigationTurns)
+	}];
+	if (request.taskInputs) messages.push({
+		role: "user",
+		content: renderTaskInputs(request.taskInputs)
+	});
+	messages.push({
+		role: "user",
+		content: request.question
+	});
+	request.log?.("trace analyst engine started", {
+		engine: ENGINE_ID,
+		model: options.model,
+		transport: options.chat.transport,
+		tools: request.tools.map((tool) => tool.name),
+		limits: request.limits
+	});
+	const trajectory = [];
+	const servedModels = /* @__PURE__ */ new Set();
+	let modelCalls = 0;
+	let toolCalls = 0;
+	let truncatedToolResults = 0;
+	let toolBudgetExhausted = false;
+	let turnsUsed = 0;
+	let stoppedOnAnswer = false;
+	for (let turn = 0; turn < investigationTurns; turn++) {
+		turnsUsed = turn + 1;
+		const response = await callModel(request, options, {
+			messages,
+			tools: toolDefinitions,
+			toolChoice: "auto",
+			purpose: "investigation"
+		});
+		modelCalls += 1;
+		servedModels.add(response.servedModel ?? "unreported");
+		const requested = response.toolCalls ?? [];
+		messages.push({
+			role: "assistant",
+			content: response.content,
+			...requested.length > 0 ? { toolCalls: requested } : {}
+		});
+		trajectory.push({
+			turn: turnsUsed,
+			phase: "investigation",
+			content: response.content,
+			tool_calls: requested.map((call) => ({
+				id: call.id,
+				name: call.name
+			})),
+			finish_reason: response.finishReason ?? null
+		});
+		if (requested.length === 0) {
+			stoppedOnAnswer = true;
+			break;
+		}
+		for (const call of requested) {
+			if (toolCalls >= request.limits.maxToolCalls) {
+				toolBudgetExhausted = true;
+				messages.push(toolMessage(call, exhaustedToolBudget(request.limits.maxToolCalls)));
+				continue;
+			}
+			toolCalls += 1;
+			const executed = await executeTool(call, toolsByName, request);
+			if (executed.truncated) truncatedToolResults += 1;
+			messages.push(toolMessage(call, executed.payload));
+			trajectory.push({
+				turn: turnsUsed,
+				phase: "tool",
+				name: call.name,
+				ok: executed.ok,
+				truncated: executed.truncated,
+				result_chars: executed.payload.length
+			});
+		}
+		if (toolBudgetExhausted) break;
+	}
+	messages.push({
+		role: "user",
+		content: reportPrompt(options.reportFormat)
+	});
+	const report = await callModel(request, options, {
+		messages,
+		purpose: "report",
+		json: options.reportFormat
+	});
+	modelCalls += 1;
+	servedModels.add(report.servedModel ?? "unreported");
+	trajectory.push({
+		turn: turnsUsed + 1,
+		phase: "report",
+		content: report.content,
+		finish_reason: report.finishReason ?? null
+	});
+	const parsed = parseReport(report.content, request.analystId, (index, reason) => {
+		request.log?.("finding rejected: report row failed schema validation", {
+			engine: ENGINE_ID,
+			index,
+			reason
+		});
+	});
+	const result = {
+		answer: parsed.answer,
+		findings: parsed.findings,
+		trajectory,
+		modelCalls,
+		toolCalls,
+		runtime: {
+			engine: ENGINE_ID,
+			model: options.model,
+			transport: options.chat.transport,
+			report_format: options.reportFormat,
+			investigation_turns: turnsUsed,
+			investigation_stopped_on_answer: stoppedOnAnswer,
+			tool_budget_exhausted: toolBudgetExhausted,
+			truncated_tool_results: truncatedToolResults,
+			rejected_findings: parsed.rejectedFindings,
+			served_models: [...servedModels].sort(),
+			task_inputs: request.taskInputs ? "prompt-delivered" : "none"
+		}
+	};
+	request.log?.("trace analyst engine completed", {
+		engine: ENGINE_ID,
+		model_calls: result.modelCalls,
+		tool_calls: result.toolCalls,
+		findings: result.findings.length
+	});
+	return result;
+}
+async function callModel(request, options, turn) {
+	const chatRequest = {
+		model: options.model,
+		messages: turn.messages.map((message) => ({ ...message })),
+		maxTokens: options.maxOutputTokens,
+		...turn.tools && turn.tools.length > 0 ? {
+			tools: turn.tools,
+			...turn.toolChoice ? { toolChoice: turn.toolChoice } : {}
+		} : {},
+		...turn.json ? { jsonMode: true } : {},
+		...turn.json === "json-schema" ? { jsonSchema: REPORT_JSON_SCHEMA } : {},
+		...options.temperature === void 0 ? {} : { temperature: options.temperature },
+		...options.thinking === void 0 ? {} : { thinking: options.thinking },
+		...options.requestTimeoutMs === void 0 ? {} : { timeoutMs: options.requestTimeoutMs }
+	};
+	const paid = await paidChat({
+		chat: options.chat,
+		request: chatRequest,
+		ledger: request.costLedger,
+		channel: "analyst",
+		phase: request.costPhase,
+		actor: request.analystId,
+		...request.costTags ? { tags: request.costTags } : {},
+		...options.pricing ? { pricing: options.pricing } : {},
+		...request.signal ? { signal: request.signal } : {}
+	});
+	if (!paid.succeeded) throw new Error(`chat trace engine ${turn.purpose} call failed for '${request.analystId}': ${paid.error.message}`, { cause: paid.error });
+	return {
+		content: paid.response.content,
+		...paid.response.toolCalls ? { toolCalls: paid.response.toolCalls } : {},
+		...paid.response.servedModel === void 0 ? {} : { servedModel: paid.response.servedModel },
+		...paid.response.finishReason === void 0 ? {} : { finishReason: paid.response.finishReason }
+	};
+}
+async function executeTool(call, toolsByName, request) {
+	const descriptor = toolsByName.get(call.name);
+	if (!descriptor) return {
+		ok: false,
+		truncated: false,
+		payload: toolError(`unknown tool '${call.name}'; available tools are ${[...toolsByName.keys()].sort().join(", ")}`)
+	};
+	let args;
+	try {
+		args = call.argumentsJson.trim() === "" ? {} : JSON.parse(call.argumentsJson);
+	} catch (error) {
+		return {
+			ok: false,
+			truncated: false,
+			payload: toolError(`arguments for '${call.name}' were not JSON: ${messageOf(error)}. Send valid JSON arguments.`)
+		};
+	}
+	try {
+		const value = await descriptor.handler(args, request.signal ? { signal: request.signal } : void 0);
+		return truncateToolPayload(JSON.stringify(value ?? null), request.limits.maxOutputChars);
+	} catch (error) {
+		if (request.signal?.aborted) throw error;
+		request.log?.("trace tool failed", {
+			engine: ENGINE_ID,
+			analyst_id: request.analystId,
+			tool: call.name,
+			reason: messageOf(error)
+		});
+		return {
+			ok: false,
+			truncated: false,
+			payload: toolError(messageOf(error))
+		};
+	}
+}
+function truncateToolPayload(payload, maxOutputChars) {
+	if (payload.length <= maxOutputChars) return {
+		ok: true,
+		truncated: false,
+		payload
+	};
+	const keep = Math.max(0, maxOutputChars - 50);
+	return {
+		ok: true,
+		truncated: true,
+		payload: `${payload.slice(0, keep)}${TRUNCATION_MARKER}`
+	};
+}
+function toolMessage(call, content) {
+	return {
+		role: "tool",
+		toolCallId: call.id,
+		content
+	};
+}
+function toolError(reason) {
+	return JSON.stringify({ error: reason });
+}
+function exhaustedToolBudget(maxToolCalls) {
+	return toolError(`the trace-tool budget of ${maxToolCalls} calls is spent; answer from the evidence already read`);
+}
+function systemPrompt(request, investigationTurns) {
+	return [request.instructions.trim(), [
+		"HOW THIS INVESTIGATION RUNS:",
+		`- You have ${investigationTurns} investigation turns and at most ${request.limits.maxToolCalls} trace-tool calls.`,
+		"- Call the trace tools to read the store. Never state a trace fact you did not read.",
+		`- A tool result longer than ${request.limits.maxOutputChars} characters is truncated; narrow the query instead of asking again.`,
+		"- A tool result carrying an \"error\" field is feedback: fix the call or take another route.",
+		"- Answer with no tool call once you have the evidence. You are then asked for the final report."
+	].join("\n")].join("\n\n");
+}
+function reportPrompt(reportFormat) {
+	return [
+		"Report now. Do not call any more tools.",
+		"Return one JSON object with exactly two fields:",
+		"  \"answer\": a direct prose answer to the question.",
+		"  \"findings\": an array of findings in the schema above. Emit [] when there is nothing to report.",
+		reportFormat === "json-object" ? "Return the object alone, with no surrounding prose and no code fence." : "Return the object in the response schema you were given."
+	].join("\n");
+}
+function renderTaskInputs(taskInputs) {
+	return ["TASK INPUTS — structured material delivered with the question, not fetched through tools:", JSON.stringify(taskInputs, null, 2)].join("\n");
+}
+function parseReport(content, analystId, onRejectedFinding) {
+	const envelope = coerceReportEnvelope(content, analystId);
+	if (typeof envelope.answer !== "string" || !envelope.answer.trim()) throw new Error(`chat trace engine report for '${analystId}' carried no answer`);
+	const decoded = decodeRawFindingArray(envelope.findings);
+	if (decoded.topLevelError !== void 0) throw new Error(`chat trace engine report for '${analystId}' had a malformed findings array: ${decoded.topLevelError}`);
+	for (const rejection of decoded.rejected) onRejectedFinding(rejection.index, `${rejection.code}${rejection.path ? ` at ${rejection.path}` : ""}: ${rejection.message}`);
+	return {
+		answer: envelope.answer,
+		findings: decoded.accepted,
+		rejectedFindings: decoded.rejected.length
+	};
+}
+function coerceReportEnvelope(content, analystId) {
+	let value;
+	try {
+		value = JSON.parse(extractJsonPayload(content));
+	} catch (error) {
+		throw new Error(`chat trace engine report for '${analystId}' was not JSON: ${messageOf(error)}`);
+	}
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw new Error(`chat trace engine report for '${analystId}' was not a JSON object`);
+	return value;
+}
+function resolveModel(options) {
+	const model = options.model ?? options.chat.defaultModel;
+	if (typeof model !== "string" || !model.trim() || model !== model.trim()) throw new TypeError("chat trace engine needs a model: pass ChatTraceEngineOptions.model or bind defaultModel on the ChatClient");
+	return model;
+}
+function messageOf(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+//#endregion
+//#region src/locked-jsonl-appender.ts
+/**
+* LockedJsonlAppender — mutex-serialized JSONL append helper for arbitrary
+* payloads. The reference-replay store does the same thing for typed
+* `ReferenceReplayRun` rows; this is the generic version used by
+* `MutationTelemetry`, `TrialTelemetry`, and any other consumer that wants
+* append-only durable telemetry without rolling its own lock.
+*
+* Locks are per absolute file path (process-local). Cross-process
+* concurrency is NOT addressed — that's an fcntl/flock problem.
+*/
+const mutexes = /* @__PURE__ */ new Map();
+function getMutex(path) {
+	let m = mutexes.get(path);
+	if (!m) {
+		m = new Mutex();
+		mutexes.set(path, m);
+	}
+	return m;
+}
+var LockedJsonlAppender = class {
+	path;
+	mutex;
+	constructor(path) {
+		this.path = path;
+		this.mutex = getMutex(path);
+		if (!existsSync(dirname(path))) mkdirSync(dirname(path), { recursive: true });
+	}
+	async append(entry) {
+		const line = `${JSON.stringify(entry)}\n`;
+		await this.mutex.runExclusive(() => {
+			appendFileSync(this.path, line);
+		});
+	}
+};
+//#endregion
+//#region src/analyst/findings-store.ts
+/**
+* FindingsStore — durable persistence for AnalystFinding rows + a diff
+* helper so we can answer "what changed since the last run?" without
+* recomputing analysts.
+*
+* On-disk shape is JSONL: one finding per line, append-only, locked via
+* LockedJsonlAppender. Operators get crash-safety (no partial JSON),
+* cheap reads (sequential parse), and trivial backup (rsync the file).
+*
+* Reads are non-locking: a reader sees a consistent snapshot of all
+* fully-written lines and skips an incomplete trailing line if the
+* writer is mid-append. Cross-process locking is intentionally out of
+* scope (see locked-jsonl-appender.ts).
+*
+* The store is run-scoped: callers pass `runId` on append and on load,
+* which keeps multi-run files cleanly partitioned. The `diffFindings`
+* helper compares two run-id sets using stable `finding_id` semantics —
+* the diff is the cross-run signal the regression dashboard renders.
+*/
+var FindingsStore = class {
+	path;
+	appender;
+	constructor(path) {
+		this.path = path;
+		this.appender = new LockedJsonlAppender(path);
+	}
+	async append(runId, findings) {
+		for (const f of findings) {
+			const row = {
+				...f,
+				run_id: runId
+			};
+			await this.appender.append(row);
+		}
+	}
+	/** Load every persisted finding. Discards malformed trailing lines silently. */
+	loadAll() {
+		if (!existsSync(this.path)) return [];
+		const raw = readFileSync(this.path, "utf8");
+		if (!raw) return [];
+		const out = [];
+		for (const line of raw.split("\n")) {
+			if (!line) continue;
+			try {
+				out.push(JSON.parse(line));
+			} catch {}
+		}
+		return out;
+	}
+	/** Filter to a single run. */
+	loadRun(runId) {
+		return this.loadAll().filter((r) => r.run_id === runId);
+	}
+};
+/**
+* Default materiality test. Deliberately narrow so LLM-reword churn
+* doesn't flood the diff. Stricter tests are opt-in via DiffPolicy.
+*/
+function defaultIsMaterial(a, b) {
+	if (a.severity !== b.severity) return true;
+	if (Math.abs((a.confidence ?? 0) - (b.confidence ?? 0)) > .05) return true;
+	if (a.evidence_refs.length !== b.evidence_refs.length) return true;
+	return false;
+}
+/**
+* Diff two findings sets by stable finding_id. Callers typically load
+* the two run-id slices from the same store and pass them in.
+*/
+function diffFindings(previous, current, policy = {}) {
+	const isMaterial = policy.isMaterial ?? defaultIsMaterial;
+	const prevById = new Map(previous.map((f) => [f.finding_id, f]));
+	const curById = new Map(current.map((f) => [f.finding_id, f]));
+	const appeared = [];
+	const disappeared = [];
+	const persisted = [];
+	const changed = [];
+	for (const [id, cur] of curById) {
+		const prev = prevById.get(id);
+		if (!prev) {
+			appeared.push(cur);
+			continue;
+		}
+		if (isMaterial(prev, cur)) changed.push({
+			previous: prev,
+			current: cur
+		});
+		else persisted.push(cur);
+	}
+	for (const [id, prev] of prevById) if (!curById.has(id)) disappeared.push(prev);
+	return {
+		appeared,
+		disappeared,
+		persisted,
+		changed
+	};
+}
+//#endregion
+//#region src/semantic-concept-judge.ts
+const DEFAULT_COMPLEXITY_WEIGHTS = {
+	render: 1,
+	integrate: 2,
+	compute: 2.5
+};
+const SEMANTIC_CONCEPT_JUDGE_VERSION = "semantic-concept-judge-v1-2026-04-24";
+const DEFAULT_MAX_SOURCE = 45e3;
+const DEFAULT_MAX_HTML = 3e4;
+const DEFAULT_MAX_PER_FILE = 2e4;
+const DEFAULT_TIMEOUT = 3e5;
+const DEFAULT_MAX_TOKENS = 16e3;
+const DEFAULT_MODEL = "claude-sonnet-4-6";
+const SEMANTIC_SCHEMA = {
+	type: "object",
+	additionalProperties: false,
+	required: ["summary", "concepts"],
+	properties: {
+		summary: {
+			type: "string",
+			minLength: 20,
+			maxLength: 600
+		},
+		concepts: {
+			type: "array",
+			minItems: 1,
+			items: {
+				type: "object",
+				additionalProperties: false,
+				required: [
+					"concept",
+					"present",
+					"score",
+					"evidence",
+					"severity"
+				],
+				properties: {
+					concept: {
+						type: "string",
+						minLength: 1,
+						maxLength: 120
+					},
+					present: { type: "boolean" },
+					score: {
+						type: "number",
+						minimum: 0,
+						maximum: 10
+					},
+					evidence: {
+						type: "string",
+						minLength: 5,
+						maxLength: 400
+					},
+					severity: {
+						type: "string",
+						enum: [
+							"critical",
+							"major",
+							"minor",
+							"info"
+						]
+					}
+				}
+			}
+		}
+	}
+};
+function truncate(body, cap, label) {
+	if (body.length <= cap) return body;
+	return `${body.slice(0, cap)}\n… [truncated ${body.length - cap} chars of ${label}]`;
+}
+function buildPrompt(input, opts) {
+	const sourceBlob = input.sourceFiles.filter((f) => f.content.length <= opts.maxPerFileChars).map((f) => `--- FILE: ${f.path} ---\n${f.content}`).join("\n\n");
+	const html = input.servedHtml ?? "";
+	return `You are a strict code-review judge evaluating whether an agent's 0-to-1 build actually implements the features the user asked for.
+
+You MUST distinguish:
+  (a) WORKING code that implements the concept (rendered UI, wired handler, real API call),
+  (b) KEYWORD-PRESENT stub (comments mentioning the concept, variable names, TODOs),
+  (c) ABSENT (concept nowhere).
+
+A comment like "// TODO: add mint button" is NOT present — score 2-3. Only count a concept as present if there is real functional code: a rendered component, a call handler wired to state or a network call, a computed value actually used.
+
+USER REQUEST (what the agent was asked to build):
+${input.userRequest}
+
+${input.artifactLabel ? `ARTIFACT METADATA:\n  name: ${input.artifactLabel}\n  description: ${input.artifactDescription ?? ""}\n\n` : ""}EXPECTED CONCEPTS (each must be graded independently):
+${input.expectedConcepts.map((c, i) => `  ${i + 1}. "${c.name}"${c.keywords?.length ? ` — hints: [${c.keywords.slice(0, 6).join(" | ")}]` : ""}`).join("\n")}
+
+${html ? `SERVED HTML (what the preview returns when hit):\n${truncate(html, opts.maxHtmlChars, "HTML")}\n\n` : ""}SOURCE FILES (the agent's workdir):
+${truncate(sourceBlob, opts.maxSourceChars, "source")}
+
+For EACH concept, return:
+  - concept: the concept name as given (match exactly)
+  - present: boolean — does a working implementation exist?
+  - score: 0-10 — 10 = production-ready; 7 = functional but thin; 4 = partial/stubbed; 2 = keyword-only comment; 0 = absent
+  - evidence: cite "<file>:<line>" or "served-html:<selector>" pointing at the strongest supporting code. If the concept is absent or stubbed, explain what's missing.
+  - severity:
+      "info" when present: true AND score >= 7
+      "minor" when present: true AND 4 <= score < 7
+      "major" when present: false OR score < 4
+      "critical" when the concept is not only absent but a core user flow depends on it
+
+Also produce a "summary" (one sentence, 20-600 chars): overall verdict on whether this is a shippable implementation of the user request vs a keyword-dense placeholder.
+
+BE SKEPTICAL. Keyword matching already passed — your job is to catch what keyword matching misses. If the agent shipped a working build, say so. If it shipped a stub, say so. Don't grade on effort.
+
+Return STRICT JSON. No prose outside the JSON.`;
+}
+/**
+* Run the semantic concept judge. Soft-fails to available=false on
+* LLM/JSON errors — callers in a MultiLayerVerifier pipeline can treat
+* that as "skip" rather than "fail."
+*/
+async function runSemanticConceptJudge(input, options) {
+	const start = Date.now();
+	const totalCount = input.expectedConcepts.length;
+	if (totalCount === 0) return {
+		kind: "semantic-concept",
+		version: SEMANTIC_CONCEPT_JUDGE_VERSION,
+		score: 0,
+		presentCount: 0,
+		totalCount: 0,
+		findings: [],
+		summary: "no expected concepts declared",
+		durationMs: 0,
+		costUsd: null,
+		available: false,
+		error: "no expected concepts declared"
+	};
+	const opts = {
+		chat: options.chat,
+		model: options.model ?? options.chat.defaultModel ?? DEFAULT_MODEL,
+		timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT,
+		maxTokens: options.maxTokens ?? DEFAULT_MAX_TOKENS,
+		maxSourceChars: options.maxSourceChars ?? DEFAULT_MAX_SOURCE,
+		maxPerFileChars: options.maxPerFileChars ?? DEFAULT_MAX_PER_FILE,
+		maxHtmlChars: options.maxHtmlChars ?? DEFAULT_MAX_HTML,
+		...options.pricing ? { pricing: options.pricing } : {},
+		costLedger: options.costLedger ?? new CostLedger(),
+		costPhase: options.costPhase ?? "judge.semantic-concept",
+		costTags: options.costTags ?? {},
+		signal: options.signal ?? new AbortController().signal,
+		weightConcepts: options.weightConcepts ?? "mean",
+		complexityWeights: {
+			...DEFAULT_COMPLEXITY_WEIGHTS,
+			...options.complexityWeights ?? {}
+		}
+	};
+	const weightForConcept = (spec) => {
+		if (opts.weightConcepts === "mean") return 1;
+		if (spec.weight != null) return spec.weight;
+		if (opts.weightConcepts === "complexity") return opts.complexityWeights[spec.complexity ?? "render"] ?? 1;
+		return 1;
+	};
+	const weightByName = new Map(input.expectedConcepts.map((c) => [c.name, weightForConcept(c)]));
+	let receipt;
+	try {
+		const request = {
+			model: opts.model,
+			messages: [{
+				role: "system",
+				content: "You are a strict code-review judge. Return strict JSON only. No prose outside the JSON. A keyword in a comment is NOT a working implementation."
+			}, {
+				role: "user",
+				content: buildPrompt(input, opts)
+			}],
+			jsonSchema: {
+				name: "semantic_concept_judge",
+				schema: SEMANTIC_SCHEMA
+			},
+			temperature: 0,
+			maxTokens: opts.maxTokens,
+			timeoutMs: opts.timeoutMs
+		};
+		const paid = await paidJsonChat({
+			chat: opts.chat,
+			request,
+			ledger: opts.costLedger,
+			channel: "judge",
+			phase: opts.costPhase,
+			actor: "semantic-concept",
+			tags: opts.costTags,
+			signal: opts.signal,
+			...opts.pricing ? { pricing: opts.pricing } : {}
+		});
+		receipt = paid.receipt;
+		if (!paid.succeeded) throw paid.error;
+		const { value } = paid;
+		if (!value?.concepts || !Array.isArray(value.concepts)) throw new Error("judge returned malformed response — expected array under \"concepts\"");
+		const findings = value.concepts.map((c) => ({
+			concept: String(c.concept),
+			present: Boolean(c.present),
+			score: Math.max(0, Math.min(10, Number(c.score ?? 0))),
+			evidence: String(c.evidence ?? ""),
+			severity: [
+				"critical",
+				"major",
+				"minor",
+				"info"
+			].includes(c.severity) ? c.severity : "info"
+		}));
+		const presentCount = findings.filter((f) => f.present && f.score >= 7).length;
+		let weightSum = 0;
+		let weightedScoreSum = 0;
+		for (const f of findings) {
+			const w = weightByName.get(f.concept) ?? 1;
+			weightSum += w;
+			weightedScoreSum += w * f.score;
+		}
+		const scoreAvg = weightSum > 0 ? weightedScoreSum / weightSum : findings.reduce((a, f) => a + f.score, 0) / Math.max(1, findings.length);
+		return {
+			kind: "semantic-concept",
+			version: SEMANTIC_CONCEPT_JUDGE_VERSION,
+			score: Number((scoreAvg / 10).toFixed(3)),
+			presentCount,
+			totalCount,
+			findings,
+			summary: String(value.summary ?? ""),
+			durationMs: Date.now() - start,
+			costUsd: paid.receipt.costUnknown ? null : paid.receipt.costUsd,
+			available: true
+		};
+	} catch (err) {
+		return {
+			kind: "semantic-concept",
+			version: SEMANTIC_CONCEPT_JUDGE_VERSION,
+			score: 0,
+			presentCount: 0,
+			totalCount,
+			findings: [],
+			summary: "",
+			durationMs: Date.now() - start,
+			costUsd: receipt && !receipt.costUnknown ? receipt.costUsd : null,
+			available: false,
+			error: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+//#endregion
+export { diffFindings as a, defaultIsMaterial as i, runSemanticConceptJudge as n, createChatTraceEngine as o, FindingsStore as r, SEMANTIC_CONCEPT_JUDGE_VERSION as t };
+
+//# sourceMappingURL=semantic-concept-judge-Ct3QU7t5.js.map