@tangle-network/agent-eval 0.144.11 → 0.144.13

package/dist/semantic-concept-judge-D1z-KepS.js

@@ -1,767 +0,0 @@
-import { o as NotFoundError } from "./errors-D-LKuDhb.js";
-import { i as CostLedger } from "./cost-ledger-DMFxsLKr.js";
-import { c as callLlmJson, f as maximumChargeForLlmRequest, l as costReceiptFromLlm, u as costReceiptFromLlmError } from "./llm-client-DzvMUsS_.js";
-import { o as computeFindingId } from "./usage-receipt-t7vAzCRQ.js";
-import { a as clamp01, i as aggregateRunScore } from "./proposal-findings-2GIUo1et.js";
-import { f as Mutex } from "./ledger-core-DXZIqu17.js";
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
-//#region src/analyst/define.ts
-/**
-* Define a reusable trace-research question.
-*
-* The returned value contains no model, credentials, or execution state. Bind
-* it to any TraceAnalysisEngine with `runTraceAnalyst` or
-* `createTraceAnalyst`.
-*/
-function defineTraceAnalyst(definition) {
-	for (const [name, value] of [
-		["id", definition.id],
-		["description", definition.description],
-		["area", definition.area],
-		["version", definition.version],
-		["instructions", definition.instructions]
-	]) if (typeof value !== "string" || !value.trim()) throw new TypeError(`defineTraceAnalyst: ${name} must be a non-empty string`);
-	return {
-		...definition,
-		limits: definition.limits ? { ...definition.limits } : void 0
-	};
-}
-function defineCustomAnalyst(options) {
-	if (!options.id.trim()) throw new TypeError("defineCustomAnalyst: id must not be empty");
-	if (!options.description.trim()) throw new TypeError("defineCustomAnalyst: description must not be empty");
-	if (options.cost === void 0) throw new TypeError("defineCustomAnalyst: cost must be declared");
-	if ("executionConfig" in options && (!options.executionConfig || typeof options.executionConfig !== "object" || Array.isArray(options.executionConfig))) throw new TypeError("defineCustomAnalyst: executionConfig must be an object");
-	return {
-		id: options.id,
-		description: options.description,
-		version: options.version ?? "1.0.0",
-		inputKind: "trace-store",
-		cost: options.cost,
-		analyze: options.analyze,
-		..."executionConfig" in options ? { executionConfig: options.executionConfig } : {}
-	};
-}
-//#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/analyst/kinds/skill-usage.ts
-/**
-* Skill-usage analyst — a DETERMINISTIC `Analyst` over a Claude/Codex skill
-* library + its trace corpus. Unlike the trace-store kinds (failure-mode,
-* improvement, ...) this kind calls no LLM: it mines real usage and skill
-* structure and emits findings by rule.
-*
-* It exists because the naive "Skill-tool invocation count" lies low — it
-* misses orchestrated sub-dispatch (a leaf skill run BY /pursue or /governor
-* logs under the parent), slash-command entry, local-script bypass, and
-* on-disk artifacts. The 2026-05-30 skill audit found 39/53 skills at zero
-* direct invocations, yet only one was a genuine cut: the rest were
-* measurement-invisible or discovery-limited. This analyst encodes that
-* lesson as a multi-signal usage model so a cheap repeatable pass can keep
-* the library honest, and so the expensive audit workflow's verdicts can
-* GEPA-distill it toward agreement (see `gold/skill-verdicts.gold.jsonl`).
-*
-* Report-building (`buildSkillUsageReport`, an fs scan) is separated from
-* finding emission (`SkillUsageAnalyst.analyze`, pure) so the slow scan runs
-* once at the registry boundary and the rule logic stays unit-testable.
-*/
-/** Anthropic's authoring guidance keeps SKILL.md short; past this with no
-*  `references/` split the body burns context budget every session. */
-const BLOAT_LINE_THRESHOLD = 300;
-const TANGLE_PRIVATE_RE = /\b(cli-bridge|tangletools|ops-board|drew-gtr-pro|@tangle-network\/|~\/company|tangle\.tools|gtm-agent)\b|\bkimi\b|\btcloud\b/gi;
-const TRIGGER_RE = /triggers?\s*[:-]/i;
-function listSkillDirs(root) {
-	if (!existsSync(root)) return [];
-	const out = [];
-	for (const entry of readdirSync(root, { withFileTypes: true })) {
-		if (!entry.isDirectory() && !entry.isSymbolicLink()) continue;
-		const skillMd = join(root, entry.name, "SKILL.md");
-		if (existsSync(skillMd)) out.push({
-			name: entry.name,
-			path: skillMd
-		});
-	}
-	return out;
-}
-function walkJsonl(dir, cap) {
-	if (!existsSync(dir)) return [];
-	const files = [];
-	const stack = [dir];
-	while (stack.length) {
-		const cur = stack.pop();
-		let entries;
-		try {
-			entries = readdirSync(cur, { withFileTypes: true });
-		} catch {
-			continue;
-		}
-		for (const e of entries) {
-			const full = join(cur, e.name);
-			if (e.isDirectory()) stack.push(full);
-			else if (e.name.endsWith(".jsonl")) {
-				files.push(full);
-				if (cap > 0 && files.length >= cap) return files;
-			}
-		}
-	}
-	return files;
-}
-function frontmatterDescription(body) {
-	const block = /^---\n([\s\S]*?)\n---/.exec(body)?.[1] ?? "";
-	return /description:\s*(.+)/i.exec(block)?.[1] ?? "";
-}
-function countArtifacts(roots, name, aliases) {
-	let n = 0;
-	for (const root of roots) {
-		const candidates = [join(root, ".evolve", name), ...aliases.map((a) => join(root, a))];
-		for (const dir of candidates) {
-			if (!existsSync(dir)) continue;
-			try {
-				if (statSync(dir).isDirectory()) n += readdirSync(dir).length;
-				else n += 1;
-			} catch {}
-		}
-	}
-	return n;
-}
-/** Scan the corpus + skill roots into a {@link SkillUsageReport}. Deterministic. */
-function buildSkillUsageReport(config) {
-	const skills = config.skillRoots.flatMap(({ root, kind }) => listSkillDirs(root).map((s) => ({
-		...s,
-		kind
-	})));
-	const names = skills.map((s) => s.name);
-	const direct = new Map(names.map((n) => [n, 0]));
-	const slash = new Map(names.map((n) => [n, 0]));
-	const skillRe = /"skill"\s*:\s*"([a-z0-9_:-]+)"/g;
-	const cmdRe = /<command-name>\/?([a-z0-9_:-]+)<\/command-name>/g;
-	let transcripts = 0;
-	for (const dir of config.transcriptDirs) for (const file of walkJsonl(dir, config.maxTranscriptsPerDir ?? 0)) {
-		transcripts += 1;
-		let data;
-		try {
-			data = readFileSync(file, "utf8");
-		} catch {
-			continue;
-		}
-		for (const m of data.matchAll(skillRe)) {
-			const g = m[1];
-			if (!g) continue;
-			const n = g.split(":").pop() ?? g;
-			const prev = direct.get(n);
-			if (prev !== void 0) direct.set(n, prev + 1);
-		}
-		for (const m of data.matchAll(cmdRe)) {
-			const g = m[1];
-			if (g === void 0) continue;
-			const prev = slash.get(g);
-			if (prev !== void 0) slash.set(g, prev + 1);
-		}
-	}
-	const bodies = /* @__PURE__ */ new Map();
-	for (const s of skills) try {
-		bodies.set(s.name, readFileSync(s.path, "utf8"));
-	} catch {
-		bodies.set(s.name, "");
-	}
-	const inbound = new Map(names.map((n) => [n, 0]));
-	for (const target of names) {
-		const ref = new RegExp(`/${target}\\b|\\[\\[${target}\\]\\]`);
-		for (const s of skills) {
-			if (s.name === target) continue;
-			if (ref.test(bodies.get(s.name) ?? "")) inbound.set(target, inbound.get(target) + 1);
-		}
-	}
-	const records = skills.map((s) => {
-		const body = bodies.get(s.name) ?? "";
-		const dir = s.path.replace(/\/SKILL\.md$/, "");
-		return {
-			name: s.name,
-			kind: s.kind,
-			path: s.path,
-			lines: body ? body.split("\n").length : 0,
-			directInvocations: direct.get(s.name) ?? 0,
-			slashInvocations: slash.get(s.name) ?? 0,
-			inboundRefs: inbound.get(s.name) ?? 0,
-			artifactCount: countArtifacts(config.artifactRoots ?? [], s.name, config.artifactAliases?.[s.name] ?? []),
-			tanglePrivateRefs: (body.match(TANGLE_PRIVATE_RE) ?? []).length,
-			hasReferencesDir: existsSync(join(dir, "references")),
-			hasEvalsDir: existsSync(join(dir, "evals")),
-			logsRuns: body.includes("skill-runs.jsonl"),
-			hasTriggerPhrases: TRIGGER_RE.test(frontmatterDescription(body) || body.slice(0, 600))
-		};
-	});
-	return {
-		generatedFromTraces: transcripts,
-		records
-	};
-}
-const ANALYST_ID = "skill-usage";
-function finding(area, subject, claim, severity, confidence, producedAt, recommended, evidenceUri, rationale) {
-	return {
-		schema_version: "1.0.0",
-		finding_id: computeFindingId({
-			analyst_id: ANALYST_ID,
-			area,
-			subject,
-			claim
-		}),
-		analyst_id: ANALYST_ID,
-		produced_at: producedAt,
-		severity,
-		area,
-		claim,
-		rationale,
-		evidence_refs: [{
-			kind: "artifact",
-			uri: evidenceUri
-		}],
-		recommended_action: recommended,
-		confidence,
-		subject
-	};
-}
-/** Pure rule pass over a report → findings. Exported for direct/unit use. */
-function emitSkillUsageFindings(report, producedAt) {
-	const out = [];
-	for (const r of report.records) {
-		const directTotal = r.directInvocations + r.slashInvocations;
-		if (directTotal + r.inboundRefs + r.artifactCount === 0) out.push(finding("skill-usage", r.name, `Skill '${r.name}' has zero usage across all signals (direct, slash, inbound-refs, artifacts)`, "high", .6, producedAt, "Confirm the skill covers a real recurring job; if not, deprecate. Zero true usage is the only deterministic deprecation candidate.", r.path, "No Skill-tool call, no slash invocation, no sibling dispatches to it, and no on-disk artifacts."));
-		else if (directTotal === 0 && r.inboundRefs + r.artifactCount > 0) out.push(finding("skill-usage", r.name, `Skill '${r.name}' shows 0 direct invocations but is used via orchestration/artifacts (inbound=${r.inboundRefs}, artifacts=${r.artifactCount})`, "info", .8, producedAt, "Do NOT treat as unused — usage is real but logged under parent skills or on disk. Strengthen direct-invocation discovery only if direct use is desired.", r.path, "The Skill-tool counter undercounts orchestrated/chained leaf skills."));
-		if (directTotal <= 2 && !r.hasTriggerPhrases) out.push(finding("discoverability", r.name, `Skill '${r.name}' is rarely invoked directly and its description has no explicit trigger phrases`, "medium", .7, producedAt, "Add a `Triggers:` clause with verbatim user phrases to the frontmatter description so the model auto-invokes it.", r.path));
-		if (r.kind === "public" && r.tanglePrivateRefs > 0) out.push(finding("safety", r.name, `Public skill '${r.name}' carries ${r.tanglePrivateRefs} Tangle-private reference(s)`, "high", .75, producedAt, "Sanitize incidental internal refs (cli-bridge/kimi/tcloud/~company/private repos) or relocate to a private repo. Verify @tangle-network/* refs are to PUBLISHED packages before treating as a leak.", r.path));
-		if (r.lines > BLOAT_LINE_THRESHOLD && !r.hasReferencesDir) out.push(finding("maintainability", r.name, `Skill '${r.name}' is ${r.lines} lines with no references/ split (progressive disclosure)`, "medium", .8, producedAt, `Split detail into references/ loaded on demand; keep SKILL.md a short overview. ${r.lines} lines load into every session's context budget.`, r.path));
-		if (!r.hasEvalsDir) out.push(finding("data-quality", r.name, `Skill '${r.name}' ships no evals/`, "low", .6, producedAt, "Add evals/evals.json with >=3 scenarios proving the skill beats baseline; gives regression coverage.", r.path));
-		if (!r.logsRuns) out.push(finding("observability", r.name, `Skill '${r.name}' never appends to .evolve/skill-runs.jsonl`, "low", .55, producedAt, "Append one run line to .evolve/skill-runs.jsonl on completion, or declare it a non-logging leaf, so the self-improvement loop can see it ran.", r.path));
-	}
-	return out;
-}
-var SkillUsageAnalyst = class {
-	id = ANALYST_ID;
-	description = "Deterministic multi-signal skill-usage analysis: flags dead skills, measurement-invisible (orchestrated) usage, discovery gaps, public-repo leaks, bloat, missing evals, and missing run-logging.";
-	inputKind = "custom";
-	cost = {
-		kind: "deterministic",
-		est_usd_per_run: 0
-	};
-	version = "1.0.0";
-	executionConfig = {
-		kind: "skill-usage",
-		bloat_line_threshold: BLOAT_LINE_THRESHOLD,
-		produced_at_source: "tags.producedAt-or-system-clock"
-	};
-	async analyze(input, ctx) {
-		const producedAt = ctx.tags?.producedAt ?? (/* @__PURE__ */ new Date()).toISOString();
-		ctx.log?.(`skill-usage: ${input.records.length} skills over ${input.generatedFromTraces} transcripts`);
-		return emitSkillUsageFindings(input, producedAt);
-	}
-};
-const SKILL_USAGE_ANALYST = new SkillUsageAnalyst();
-//#endregion
-//#region src/run-critic.ts
-const DEFAULT_DRIFT_PATTERNS = [
-	/https?:\/\//i,
-	/\btitle:\s/i,
-	/\bsummary:\s/i,
-	/\burl:\s/i,
-	/\bnpm package usage\b/i,
-	/\bnews\b/i
-];
-var RunCritic = class {
-	weights;
-	driftPatterns;
-	constructor(options = {}) {
-		this.weights = options.weights;
-		this.driftPatterns = options.driftPatterns ?? DEFAULT_DRIFT_PATTERNS;
-	}
-	async score(store, runId) {
-		const run = await store.getRun(runId);
-		if (!run) throw new NotFoundError(`run ${runId} not found`);
-		const [spans, events, artifacts, budget] = await Promise.all([
-			store.spans({ runId }),
-			store.events({ runId }),
-			store.artifacts(runId),
-			store.budget(runId)
-		]);
-		return this.scoreTrace({
-			run,
-			spans,
-			events,
-			artifacts,
-			budget
-		});
-	}
-	scoreTrace(trace) {
-		const notes = [];
-		const llmSpans = trace.spans.filter((s) => s.kind === "llm");
-		const toolSpans = trace.spans.filter((s) => s.kind === "tool");
-		const judgeSpans = trace.spans.filter((s) => s.kind === "judge");
-		const sandboxSpans = trace.spans.filter((s) => s.kind === "sandbox");
-		const finalGateSpans = judgeSpans.filter((span) => span.dimension === "final_gate" || span.attributes?.finalGate === true);
-		const success = trace.run.outcome?.pass === true ? 1 : trace.run.status === "completed" ? .5 : 0;
-		if (!success) notes.push("run did not complete with pass=true");
-		const judgeAverage = judgeSpans.length ? judgeSpans.reduce((sum, span) => sum + normalizeJudgeScore(span.score), 0) / judgeSpans.length : void 0;
-		const goalProgress = (typeof trace.run.outcome?.score === "number" ? clamp01(trace.run.outcome.score > 1 ? trace.run.outcome.score / 100 : trace.run.outcome.score) : void 0) ?? judgeAverage ?? success;
-		const successfulTools = toolSpans.filter((span) => span.status !== "error").length;
-		const toolUseQuality = toolSpans.length === 0 ? 0 : successfulTools / toolSpans.length;
-		if (toolSpans.length === 0) notes.push("no tool spans recorded");
-		const patchEvidence = trace.artifacts.length + toolSpans.filter((span) => /write|edit|patch|apply/i.test(span.toolName)).length;
-		const patchQuality = patchEvidence > 0 ? clamp01(patchEvidence / 4) : 0;
-		if (!patchQuality) notes.push("no artifact or edit evidence recorded");
-		const sandboxTests = sandboxSpans.filter((span) => typeof span.testsTotal === "number" && span.testsTotal > 0);
-		const testReality = sandboxTests.length ? sandboxTests.reduce((sum, span) => sum + (span.testsPassed ?? 0) / Math.max(1, span.testsTotal ?? 1), 0) / sandboxTests.length : toolSpans.some((span) => /\btest|vitest|pytest|jest|build|tsc\b/i.test(JSON.stringify(span.args))) ? .4 : 0;
-		if (!testReality) notes.push("no real test/build evidence recorded");
-		const blockerSpans = judgeSpans.filter((span) => isBlockingJudge(span));
-		const finalGateBlockers = finalGateSpans.filter((span) => isBlockingJudge(span));
-		const finalGate = finalGateSpans.length ? finalGateBlockers.length ? 0 : 1 : success;
-		if (finalGateBlockers.length) notes.push(`final gate blocked by ${finalGateBlockers.length} reviewer(s)`);
-		else if (!finalGateSpans.length) notes.push("no final gate judgment recorded");
-		const reviewerBlockers = judgeSpans.length ? blockerSpans.length / judgeSpans.length : 0;
-		if (reviewerBlockers) notes.push(`detected ${blockerSpans.length} blocking reviewer signal(s)`);
-		const positiveGroundingSignals = patchEvidence + sandboxSpans.length + llmSpans.filter((span) => looksRepoGrounded(span.output ?? "")).length;
-		const driftSignals = llmSpans.filter((span) => this.isDrift(span.output ?? "")).length + trace.events.filter((event) => this.isDrift(JSON.stringify(event.payload))).length;
-		const repoGroundedness = positiveGroundingSignals + driftSignals === 0 ? 0 : positiveGroundingSignals / (positiveGroundingSignals + driftSignals);
-		const driftPenalty = positiveGroundingSignals + driftSignals === 0 ? 0 : driftSignals / (positiveGroundingSignals + driftSignals);
-		if (driftSignals > 0) notes.push(`detected ${driftSignals} drift signal(s)`);
-		return {
-			success,
-			goalProgress,
-			repoGroundedness,
-			driftPenalty,
-			toolUseQuality,
-			patchQuality,
-			testReality,
-			finalGate,
-			reviewerBlockers,
-			costUsd: trace.budget.length ? Math.max(...trace.budget.filter((entry) => entry.dimension === "usd").map((entry) => entry.consumed), 0) : llmSpans.reduce((sum, span) => sum + (span.costUsd ?? 0), 0),
-			wallSeconds: trace.run.endedAt && trace.run.startedAt ? Math.max(0, (trace.run.endedAt - trace.run.startedAt) / 1e3) : 0,
-			notes
-		};
-	}
-	rank(score) {
-		return aggregateRunScore(score, this.weights);
-	}
-	isDrift(text) {
-		return this.driftPatterns.some((pattern) => pattern.test(text));
-	}
-};
-function normalizeJudgeScore(score) {
-	return score > 1 ? clamp01(score / 10) : clamp01(score);
-}
-function looksRepoGrounded(text) {
-	return /(?:src\/|tests?\/|package\.json|tsconfig|\.ts\b|\.tsx\b|git status|pnpm |npm |vitest|pytest|jest)/i.test(text);
-}
-function isBlockingJudge(span) {
-	return span.attributes?.blocking === true || span.attributes?.verdict === "BLOCKING" || positiveNumber(span.attributes?.blockingFindings) || positiveNumber(span.attributes?.highFindings) || span.score <= 2;
-}
-function positiveNumber(value) {
-	return typeof value === "number" && value > 0;
-}
-//#endregion
-//#region src/semantic-concept-judge.ts
-/**
-* Semantic concept judge — "does the built artifact actually implement
-* the features the user asked for?"
-*
-* Distinct from the domain/code/coherence judges in `judges.ts`:
-*   - those judges score free-form conversational agent outputs along
-*     quality dimensions (accuracy, depth, etc.)
-*   - this judge scores a *built artifact* (served HTML + source files)
-*     against an explicit list of expected concepts, returning per-concept
-*     {present, score 0-10, evidence, severity}.
-*
-* The judge is strict about distinguishing (a) a working implementation
-* from (b) a keyword-present stub. "// TODO: mint button" is NOT present.
-* Only real, functional, wired-up code counts.
-*
-* Use via {@link createSemanticConceptJudge} or directly via
-* {@link runSemanticConceptJudge}. Soft-fails (available=false) on LLM
-* or JSON-parse errors so the caller can treat that as "layer skipped"
-* rather than "layer failed" in a multi-layer pipeline.
-*/
-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 = {
-		model: options.model ?? 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,
-		llm: options.llm ?? {},
-		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 opts.costLedger.runPaidCall({
-			channel: "judge",
-			phase: opts.costPhase,
-			actor: "semantic-concept",
-			model: opts.model,
-			...Object.keys(opts.costTags).length > 0 ? { tags: opts.costTags } : {},
-			maximumCharge: maximumChargeForLlmRequest(request, opts.llm),
-			signal: opts.signal,
-			execute: (signal, callId) => callLlmJson(request, {
-				...opts.llm,
-				signal,
-				idempotencyKey: callId
-			}),
-			receipt: ({ result }) => costReceiptFromLlm(result),
-			receiptFromError: costReceiptFromLlmError
-		});
-		receipt = paid.receipt;
-		if (!paid.succeeded) throw paid.error;
-		const { value } = paid.value;
-		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)
-		};
-	}
-}
-/**
-* Factory: pin LLM options once, return a closure that accepts inputs.
-* Convenient for pipelines that want to share a single LlmClient config.
-*/
-function createSemanticConceptJudge(options = {}) {
-	return (input) => runSemanticConceptJudge(input, options);
-}
-//#endregion
-export { RunCritic as a, buildSkillUsageReport as c, defaultIsMaterial as d, diffFindings as f, defineTraceAnalyst as h, runSemanticConceptJudge as i, emitSkillUsageFindings as l, defineCustomAnalyst as m, SEMANTIC_CONCEPT_JUDGE_VERSION as n, SKILL_USAGE_ANALYST as o, LockedJsonlAppender as p, createSemanticConceptJudge as r, SkillUsageAnalyst as s, DEFAULT_COMPLEXITY_WEIGHTS as t, FindingsStore as u };
-
-//# sourceMappingURL=semantic-concept-judge-D1z-KepS.js.map