@hawkeyexl/manni 4.4.1 → 4.6.0

package/dist/check-WB2QDHJQ.js

@@ -0,0 +1,880 @@
+#!/usr/bin/env node
+import {
+  clipTo,
+  historyBlock,
+  ledgerPath,
+  projectPath,
+  readLedger,
+  recordFacts,
+  recordTurn,
+  rollup,
+  turnFacts,
+  writeLedger
+} from "./chunk-N7JSEDSC.js";
+import {
+  JUDGE_ENV,
+  assertDownloaded,
+  conformanceOf,
+  extraction,
+  firstLine,
+  isNetworkProvider,
+  localGate,
+  markJudgeProcess,
+  mockTurnJudge,
+  offlineRefusal,
+  rulesCacheFor
+} from "./chunk-FLAO4ZS3.js";
+import {
+  isTypedPrompt,
+  lastTurn,
+  resolveTurnSources,
+  subagentTurn
+} from "./chunk-YLK2J5YK.js";
+import {
+  libraryLocalModels,
+  renderCheck
+} from "./chunk-TH4JVQPF.js";
+import {
+  QUEUE_WAIT_MS,
+  hostHolds,
+  hostSetting,
+  queued
+} from "./chunk-WQWKYAAK.js";
+import {
+  parseTraceFile,
+  renderTrace
+} from "./chunk-M2RLHZ4J.js";
+import {
+  evaluateWhen
+} from "./chunk-FQGLRJGX.js";
+import {
+  materialize
+} from "./chunk-CWXZ2MRT.js";
+import "./chunk-APKH2T6E.js";
+import "./chunk-4TSWU2SU.js";
+import {
+  discoverConfig
+} from "./chunk-XPEWUK7J.js";
+import {
+  makeRedactor
+} from "./chunk-CU57HT2E.js";
+import {
+  constructProvider,
+  resolveSelectionIdentity,
+  selectHookProvider,
+  selectProvider
+} from "./chunk-BWCWTHYS.js";
+import {
+  TracevalsError
+} from "./chunk-UKZNLVJW.js";
+import "./chunk-YNHZHSSM.js";
+import "./chunk-TLXE7LYK.js";
+import "./chunk-GREQKO6M.js";
+import "./chunk-TUAAR3MM.js";
+import "./chunk-5G53XATW.js";
+import "./chunk-KCOFEWV5.js";
+import "./chunk-YEUYKR62.js";
+import "./chunk-RNVYGWIC.js";
+import "./chunk-MNH7QO4Z.js";
+import "./chunk-XKBEHKWO.js";
+import {
+  warn
+} from "./chunk-HX44GB4Z.js";
+import {
+  DECISION_ONLY_PROVIDERS
+} from "./chunk-QCHVR4ZM.js";
+import "./chunk-PCFG7E6B.js";
+import "./chunk-OWBRDNRZ.js";
+import "./chunk-G3T47CFV.js";
+import "./chunk-2H7UOFLK.js";
+
+// src/tracevals/commands/check.ts
+import { writeFile } from "node:fs/promises";
+import { basename, resolve } from "node:path";
+
+// src/tracevals/rules/judge.ts
+import {
+  JsonCache,
+  buildCacheKey,
+  canDecide,
+  completeJSONShared,
+  sha256
+} from "@hawkeyexl/inference";
+
+// src/tracevals/rules/judge-prompt.ts
+var TURN_JUDGE_PROMPT_VERSION = 7;
+var TURN_JUDGE_SYSTEM_PROMPT = [
+  "You check the last turn of an AI coding agent's session against one rule.",
+  "The last turn starts at the last prompt the user typed and runs to the end of the transcript.",
+  "The transcript shows the user's prompts, the agent's tool calls with their inputs, and its replies.",
+  '"Earlier in this session" lists what the session did before the last turn.',
+  "",
+  "A prompt the user typed overrides any rule. Doing what the user explicitly asked is never a violation.",
+  "",
+  "Judge only from what the transcript and the earlier turns show. Do not guess.",
+  "A rule applies only once the session does the kind of work it covers.",
+  "Score it broken only for what the last turn did, or for the last turn saying the work is done without it."
+].join("\n");
+var TURN_SCORES = ["not-applicable", "followed", "not-followed"];
+var SCORE = { type: "integer", minimum: 0, maximum: 100 };
+var TURN_SCHEMA = {
+  type: "object",
+  required: ["reasoning", ...TURN_SCORES],
+  additionalProperties: false,
+  properties: {
+    reasoning: { type: "string" },
+    "not-applicable": SCORE,
+    followed: SCORE,
+    "not-followed": SCORE
+  }
+};
+var TURN_CRITERIA = {
+  followed: "The session does what the rule asks.",
+  "not-followed": "The last turn did what the rule forbids, skipped what it requires, or said the work is done without it.",
+  "not-applicable": "The rule does not apply yet, or the last turn did nothing it covers."
+};
+function ruleKey(displayPath, id) {
+  return `${displayPath}#${id}`;
+}
+function buildTurnShared(turn, earlier = "") {
+  return `${earlier !== "" ? `${earlier}
+
+` : ""}# The turn
+
+${turn}
+
+`;
+}
+function buildRuleItem(displayPath, rule, history = "") {
+  return [
+    "# The rule",
+    "",
+    `${ruleKey(displayPath, rule.id)}: ${rule.text}`,
+    "",
+    ...history !== "" ? [history, ""] : [],
+    "First say in one or two sentences what the session shows about this rule. Then score each as a whole number from 0 to 100: the rule does not apply yet, or the last turn did nothing it covers; the session follows it; the last turn broke it, or the last turn says the work is done without it."
+  ].join("\n");
+}
+function buildDecisionState(turn, earlier = "") {
+  return `${TURN_JUDGE_SYSTEM_PROMPT}
+
+${buildTurnShared(turn, earlier)}`;
+}
+function questionFor(displayPath, rule) {
+  return {
+    type: "choice",
+    instructions: `Did this turn follow ${ruleKey(displayPath, rule.id)}? The rule: ${rule.text}`,
+    criteria: { ...TURN_CRITERIA }
+  };
+}
+
+// src/tracevals/rules/timeline.ts
+var HEAD = "# Earlier in this session\n\n";
+var RESULT_CHARS = 120;
+var TICK_CHARS = 60;
+var SPAWNS = 10;
+var TASK = /^\s*-\s+\[([ xX])\]\s+(.+?)\s*$/;
+var TASK_ID = /^(?:[A-Z]+(?:-[A-Z]+)*-?\d+(?:\.\d+)*|\d+(?:\.\d+)*)(?=[\s:.)\]]|$)/;
+var isRecord = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function toolResults(trace) {
+  const out = /* @__PURE__ */ new Map();
+  for (const e of trace.events) {
+    if (e.kind !== "tool_result") continue;
+    const message = e.raw.message;
+    const content = isRecord(message) ? message.content : void 0;
+    if (!Array.isArray(content)) continue;
+    for (const block of content) {
+      if (!isRecord(block) || block.type !== "tool_result" || typeof block.tool_use_id !== "string") continue;
+      const body = block.content;
+      const text = typeof body === "string" ? body : Array.isArray(body) ? body.flatMap((b) => isRecord(b) && typeof b.text === "string" ? [b.text] : []).join("\n") : "";
+      out.set(block.tool_use_id, { text, isError: block.is_error === true });
+    }
+  }
+  return out;
+}
+function callId(trace, index) {
+  const id = trace.events.find((e) => e.index === index)?.raw.id;
+  return typeof id === "string" ? id : void 0;
+}
+function tasks(text, ticked) {
+  return text.split(/\r?\n/).flatMap((line) => {
+    const m = TASK.exec(line);
+    const box = m?.[1];
+    const body = m?.[2];
+    if (box === void 0 || body === void 0) return [];
+    return box !== " " === ticked ? [body] : [];
+  });
+}
+function ticks(oldText, newText) {
+  if (typeof oldText !== "string" || typeof newText !== "string") return [];
+  const now = new Set(tasks(newText, true));
+  return tasks(oldText, false).filter((t) => now.has(t));
+}
+var list = (verb, items) => items.length > 0 ? [`${verb} ${items.join(", ")}`] : [];
+function timelineBlock(trace, before, opts) {
+  const scrub = makeRedactor(opts.redact);
+  const results = toolResults(trace);
+  const starts = trace.events.filter((e) => e.index < before && e.sidechain !== true && isTypedPrompt(e)).map((e) => e.index);
+  const lines = starts.flatMap((from, i) => {
+    const end = starts[i + 1] ?? before;
+    const window = materialize(trace, "turn", "earlier turn", [{ start: from, end }], void 0, /* @__PURE__ */ new Set([void 0]));
+    const facts = turnFacts(trace, { window, from, to: end - 1, sessionTurnCount: 0 }, opts.sources, opts);
+    const spawns = trace.agentSpawns.filter((a) => a.index >= from && a.index < end).slice(0, SPAWNS).map((a) => {
+      const result = results.get(a.toolUseId ?? callId(trace, a.index) ?? "");
+      const first = scrub(result?.text ?? "").trim().split(/\r?\n/)[0]?.trim() ?? "";
+      return first === "" ? `spawned ${a.subagentType}` : `spawned ${a.subagentType}, which returned ${clipTo(first, RESULT_CHARS)}`;
+    });
+    const calls = window.toolCalls;
+    const asked = calls.some((c) => c.name === "AskUserQuestion") ? ["asked the user"] : [];
+    const ticked = calls.flatMap((c) => {
+      if (typeof c.input.file_path !== "string") return [];
+      const edits = c.name === "Edit" ? [c.input] : c.name === "MultiEdit" && Array.isArray(c.input.edits) ? c.input.edits : [];
+      const path = scrub(projectPath(c.input.file_path, opts.cwd, opts.root));
+      return edits.flatMap(
+        (e) => isRecord(e) ? ticks(e.old_string, e.new_string).map((t) => {
+          const safe = scrub(t);
+          return `ticked ${TASK_ID.exec(safe)?.[0] ?? clipTo(safe, TICK_CHARS)} in ${path}`;
+        }) : []
+      );
+    });
+    const approved = calls.some((c) => {
+      if (c.name !== "ExitPlanMode") return false;
+      const result = results.get(callId(trace, c.index) ?? "");
+      return result !== void 0 && !result.isError;
+    }) ? ["had a plan approved"] : [];
+    const parts = [
+      ...list("ran", facts.commands),
+      ...list("wrote", facts.wrote),
+      ...list("read", facts.read),
+      ...facts.skills.map((s) => `ran skill ${s}`),
+      ...spawns,
+      ...asked,
+      ...[...new Set(ticked)],
+      ...approved
+    ];
+    if (parts.length === 0) return [];
+    const out = opts.ledger?.turns.find((t) => t.turn === from)?.inScope === false;
+    return [{ turn: from, line: `- turn ${String(from)}: ${parts.join("; ")}${out ? " (no rules in scope)" : ""}` }];
+  });
+  const max = opts.maxChars ?? Number.POSITIVE_INFINITY;
+  const marker = (n) => {
+    const a = String(lines[0]?.turn);
+    const b = String(lines[n - 1]?.turn);
+    return n === 1 ? `- (turn ${a}: 1 line left out)` : `- (turns ${a}\u2013${b}: ${String(n)} lines left out)`;
+  };
+  let kept = lines.reduce((sum, l) => sum + l.line.length + 1, HEAD.length - 1);
+  let dropped = 0;
+  const size = () => kept + (dropped > 0 ? marker(dropped).length + 1 : 0);
+  while (dropped < lines.length && size() > max) {
+    kept -= (lines[dropped]?.line.length ?? 0) + 1;
+    dropped += 1;
+  }
+  if (dropped === lines.length) return "";
+  const shown = lines.slice(dropped).map((l) => l.line);
+  return `${HEAD}${[...dropped > 0 ? [marker(dropped)] : [], ...shown].join("\n")}`;
+}
+
+// src/tracevals/rules/judge.ts
+var DEFAULT_TURN_CACHE_DIR = ".manni/tracevals/cache/turns";
+var CHARS_PER_TOKEN = 3;
+var isRecord2 = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+function isScores(v) {
+  return isRecord2(v) && TURN_SCORES.every((s) => typeof v[s] === "number");
+}
+var TurnCache = class {
+  store;
+  constructor(dir = DEFAULT_TURN_CACHE_DIR, enabled = true) {
+    this.store = new JsonCache(dir, enabled, "manni-tracevals");
+  }
+  /** An entry of any other shape, from an older version, is a miss. */
+  get(key) {
+    const v = this.store.get(key);
+    if (!isRecord2(v) || !Array.isArray(v.runs) || v.runs.length === 0) return void 0;
+    const runs = v.runs;
+    return runs.every(isScores) ? runs : void 0;
+  }
+  set(key, runs) {
+    this.store.set(key, { runs });
+  }
+};
+var StateLimits = class {
+  store;
+  constructor(dir, enabled = true) {
+    this.store = new JsonCache(dir, enabled, "manni-tracevals");
+  }
+  get(id) {
+    const v = this.store.get(buildCacheKey([id.provider, id.model]));
+    return isRecord2(v) && (v.limit === null || typeof v.limit === "number") ? v.limit : void 0;
+  }
+  set(id, limit) {
+    this.store.set(buildCacheKey([id.provider, id.model]), { limit });
+  }
+};
+function applicableRules(rules, window) {
+  const applicable = rules.filter(
+    (r) => evaluateWhen({ when: r.rule.when }, window).armed
+  );
+  return { applicable, notApplicable: rules.length - applicable.length };
+}
+var round = (n) => Math.round(n * 100) / 100;
+function decisionOnly(provider) {
+  return DECISION_ONLY_PROVIDERS.has(provider.provider()) && canDecide(provider) ? provider : void 0;
+}
+function planTurn(input, id, decisionOnly2, limit) {
+  const runs = decisionOnly2 ? 1 : input.runs;
+  const { applicable } = applicableRules(input.rules, input.turn.window);
+  const warnings = [];
+  const hits = /* @__PURE__ */ new Map();
+  const sourceIndex = /* @__PURE__ */ new Map();
+  for (const r of input.rules) {
+    const path = r.source.displayPath;
+    if (!sourceIndex.has(path)) sourceIndex.set(path, sourceIndex.size);
+  }
+  const planned = applicable.map(({ source, rule }) => {
+    const history = !decisionOnly2 && input.ledger !== void 0 ? historyBlock(input.ledger, ruleKey(source.displayPath, rule.id), rule.text, input.turn.from) : "";
+    return {
+      qid: `${String(sourceIndex.get(source.displayPath))}:${rule.id}`,
+      source: source.displayPath,
+      id: rule.id,
+      text: rule.text,
+      history,
+      item: buildRuleItem(source.displayPath, rule, history)
+    };
+  });
+  if (planned.length === 0) {
+    return { planned, turnText: "", earlier: "", warnings, hits, todo: [], keyOf: () => "" };
+  }
+  const tail = lastMessageLine(input);
+  let budget = input.render.maxTotalChars;
+  let byLimit = false;
+  if (limit !== void 0) {
+    const longest = Math.max(
+      ...planned.map(
+        (p) => decisionOnly2 ? JSON.stringify(questionFor(p.source, p)).length : p.item.length
+      )
+    );
+    const fixed = decisionOnly2 ? buildDecisionState("").length : TURN_JUDGE_SYSTEM_PROMPT.length + buildTurnShared("").length;
+    const fit = limit * CHARS_PER_TOKEN - longest - fixed;
+    if (fit < budget) {
+      budget = fit;
+      byLimit = true;
+    }
+  }
+  const sources = [
+    ...new Map(
+      input.rules.flatMap(
+        ({ source: { path, displayPath } }) => (
+          // A source with no file (the typed prompts, an inline plan) is never read.
+          path !== void 0 && path !== "" ? [[displayPath, { path, displayPath }]] : []
+        )
+      )
+    ).values()
+  ];
+  const earlier = timelineBlock(input.trace, input.turn.from, {
+    cwd: input.project?.cwd ?? input.trace.cwd,
+    root: input.project?.root ?? input.trace.cwd,
+    redact: input.render.redact,
+    sources,
+    ...input.ledger !== void 0 ? { ledger: input.ledger } : {},
+    maxChars: Math.floor(budget / 4)
+  });
+  budget -= buildTurnShared("", earlier).length - buildTurnShared("").length;
+  const cut = { happened: false };
+  const turnText = renderTrace(input.trace, {
+    maxBlockChars: input.render.maxBlockChars,
+    maxTotalChars: budget - tail.length,
+    redact: input.render.redact,
+    window: input.turn.window,
+    onTruncated: () => {
+      cut.happened = true;
+    }
+  }) + tail;
+  if (cut.happened) {
+    warnings.push(
+      byLimit ? `the turn was cut to fit the state limit of ${String(limit)} tokens of ${id.provider}/${id.model}; the judge saw its head and tail` : `the turn was cut to the render cap of ${String(input.render.maxTotalChars)} characters; the judge saw its head and tail`
+    );
+  }
+  const base = [
+    id.provider,
+    id.model,
+    decisionOnly2 ? "decision" : "generative",
+    `r${String(runs)}`,
+    `t${String(input.temperature)}`,
+    `turn-v${String(TURN_JUDGE_PROMPT_VERSION)}`,
+    sha256(turnText),
+    sha256(earlier)
+  ];
+  const keyOf = (p) => buildCacheKey([...base, sha256(JSON.stringify([p.source, p.id, p.text, p.history]))]);
+  const todo = [];
+  for (const p of planned) {
+    const hit = input.cache?.get(keyOf(p));
+    if (hit !== void 0) hits.set(p, { runs: hit });
+    else todo.push(p);
+  }
+  return { planned, turnText, earlier, warnings, hits, todo, keyOf };
+}
+function allVerdictsCached(input, id) {
+  const limit = input.limits.get(id);
+  if (limit === void 0 || DECISION_ONLY_PROVIDERS.has(id.provider)) return false;
+  const plan = planTurn(input, id, false, limit ?? void 0);
+  return plan.planned.length > 0 && plan.todo.length === 0;
+}
+async function judgeTurn(input) {
+  const { provider, zones } = input;
+  const decider = decisionOnly(provider);
+  const mode = decider !== void 0 ? "decision" : "generative";
+  const runs = decider !== void 0 ? 1 : input.runs;
+  const id = { provider: provider.provider(), model: provider.modelName() };
+  const { applicable, notApplicable } = applicableRules(input.rules, input.turn.window);
+  const result = {
+    mode,
+    runs,
+    findings: [],
+    verdicts: [],
+    judged: applicable.length,
+    notApplicable,
+    cached: false,
+    warnings: []
+  };
+  if (applicable.length === 0) return result;
+  const fresh = async () => {
+    const real = canDecide(provider) ? await provider.stateLimit() : null;
+    input.limits?.set(id, real);
+    return real;
+  };
+  const remembered = input.limits?.get(id);
+  let limit = remembered ?? await fresh();
+  let plan = planTurn(input, id, decider !== void 0, limit ?? void 0);
+  if (remembered !== void 0 && plan.todo.length > 0) {
+    const real = await fresh();
+    if (real !== limit) {
+      limit = real;
+      plan = planTurn(input, id, decider !== void 0, limit ?? void 0);
+    }
+  }
+  const { planned, hits: verdicts, todo, keyOf, turnText, earlier } = plan;
+  const warnings = plan.warnings;
+  result.warnings = warnings;
+  result.cached = todo.length === 0;
+  if (todo.length > 0) {
+    const scored = decider !== void 0 ? await decide(decider, todo, buildDecisionState(turnText, earlier)) : await score(provider, todo, buildTurnShared(turnText, earlier), runs, input.temperature);
+    if (scored.every((v) => v.runs.length === 0)) {
+      throw new Error(scored.find((v) => v.error !== void 0)?.error ?? "every judge call errored");
+    }
+    const errored = scored.filter((v) => v.error !== void 0);
+    if (errored.length > 0) {
+      warnings.push(
+        `the judge errored on ${String(errored.length)} of ${String(todo.length)} rules, so they need review: ${errored[0]?.error ?? ""}`
+      );
+    }
+    todo.forEach((p, i) => {
+      const v = scored[i] ?? { runs: [], error: "the judge returned nothing" };
+      verdicts.set(p, v);
+      if (v.error === void 0) input.cache?.set(keyOf(p), v.runs);
+    });
+  }
+  for (const p of planned) {
+    const v = verdicts.get(p) ?? { runs: [], error: "the judge returned nothing" };
+    const outcome = outcomeOf(v, runs, zones);
+    const reasoning = v.runs.find((r) => typeof r.reasoning === "string")?.reasoning;
+    result.verdicts.push({
+      source: p.source,
+      rule: p.id,
+      text: p.text,
+      outcome,
+      ...reasoning !== void 0 ? { reasoning } : {}
+    });
+    if (outcome === "not-applicable") result.notApplicable += 1;
+    else if (outcome !== "followed") result.findings.push(findingOf(p, outcome, v, runs));
+  }
+  return result;
+}
+async function decide(decider, todo, state) {
+  const response = await decider.decide({
+    state,
+    questions: Object.fromEntries(todo.map((p) => [p.qid, questionFor(p.source, p)]))
+  });
+  const answers = response.answers;
+  return todo.map((p) => {
+    const answer = answers[p.qid];
+    if (answer === void 0) return { runs: [], error: "the judge returned no answer for this rule" };
+    const pct = (s) => Math.round((answer.probabilities[s] ?? 0) * 100);
+    return {
+      runs: [
+        {
+          followed: pct("followed"),
+          "not-followed": pct("not-followed"),
+          "not-applicable": pct("not-applicable")
+        }
+      ]
+    };
+  });
+}
+async function score(provider, todo, shared, runs, temperature) {
+  const verdicts = todo.map(() => ({ runs: [] }));
+  const errors = todo.map(() => 0);
+  for (let run = 0; run < runs; run++) {
+    const response = await completeJSONShared(provider, {
+      system: TURN_JUDGE_SYSTEM_PROMPT,
+      shared,
+      items: todo.map((p) => p.item),
+      schema: TURN_SCHEMA,
+      temperature
+    });
+    verdicts.forEach((v, i) => {
+      const answer = response.answers[i];
+      if (answer !== void 0 && "json" in answer && isScores(answer.json)) {
+        v.runs.push(answer.json);
+        return;
+      }
+      errors[i] = (errors[i] ?? 0) + 1;
+      v.error ??= answer !== void 0 && "error" in answer ? answer.error : "the judge returned nothing";
+    });
+  }
+  return verdicts.map(
+    (v, i) => v.error === void 0 || v.runs.length === 0 ? v : { ...v, error: `${String(errors[i] ?? 0)} of ${String(runs)} runs errored: ${v.error}` }
+  );
+}
+function classify(s, zones) {
+  if (s["not-followed"] / 100 >= zones.autoFail) return "fail";
+  if (s["not-applicable"] / 100 >= zones.autoPass) return "not-applicable";
+  if (s.followed / 100 >= zones.autoPass) return "followed";
+  return "needs-review";
+}
+function outcomeOf(v, runs, zones) {
+  if (v.error !== void 0 || v.runs.length < runs) return "needs-review";
+  const each = v.runs.map((s) => classify(s, zones));
+  if (each.every((c) => c === "fail")) return "fail";
+  if (each.every((c) => c === "not-applicable")) return "not-applicable";
+  if (each.every((c) => c === "not-applicable" || c === "followed")) return "followed";
+  return "needs-review";
+}
+function findingOf(p, outcome, v, runs) {
+  const base = { source: p.source, rule: p.id, text: p.text, outcome };
+  if (v.runs.length === 0) {
+    return {
+      ...base,
+      observed: `the judge returned no answer for this rule: ${v.error ?? ""}`,
+      confidence: 0
+    };
+  }
+  const mean = (s) => Math.round(v.runs.reduce((sum, r) => sum + r[s], 0) / v.runs.length);
+  const scores = `not-followed ${String(mean("not-followed"))}, followed ${String(mean("followed"))}, not-applicable ${String(mean("not-applicable"))}`;
+  const errored = v.error !== void 0 && runs > 1 ? `; ${v.error}` : "";
+  const reasoning = v.runs.find((r) => typeof r.reasoning === "string")?.reasoning;
+  return {
+    ...base,
+    observed: `${scores}${errored}${reasoning !== void 0 ? `. ${reasoning}` : ""}`,
+    confidence: round(mean("not-followed") / 100),
+    ...reasoning !== void 0 ? { reasoning } : {}
+  };
+}
+function lastMessageLine(input) {
+  const message = input.lastAssistantMessage?.trim();
+  if (message === void 0 || message === "") return "";
+  if (input.turn.window.assistantTexts.at(-1)?.trim() === message) return "";
+  const safe = makeRedactor(input.render.redact)(message);
+  const max = input.render.maxBlockChars;
+  const clipped = safe.length <= max ? safe : `${safe.slice(0, max)} [... truncated ${String(safe.length - max)} chars ...]`;
+  return `
+[assistant] ${clipped}`;
+}
+
+// src/tracevals/commands/check.ts
+var idOf = (p) => ({
+  provider: p.provider(),
+  model: p.modelName()
+});
+var LEDGER_OUTCOME = {
+  fail: "broken",
+  followed: "followed",
+  "needs-review": "needs-review",
+  "not-applicable": "not-applicable"
+};
+async function conform(p) {
+  const ledgerFile = ledgerPath(p.projectDir, p.sessionId, p.agentId);
+  const ledger = await readLedger(ledgerFile);
+  const seen = { sources: [] };
+  const outcome = await judgeTurnOf(p, ledger, seen);
+  if (p.inLoop) await record(p, ledgerFile, ledger, seen);
+  else if (outcome.kind === "report") outcome.report.session = rollup(ledger);
+  return outcome;
+}
+async function record(p, file, ledger, seen) {
+  const facts = turnFacts(p.trace, p.turn, seen.sources, {
+    cwd: p.projectDir,
+    root: p.projectRoot ?? p.projectDir,
+    redact: p.config.judge.redact
+  });
+  let next = recordFacts(ledger, facts);
+  if (seen.judgement !== void 0) {
+    next = recordTurn(
+      next,
+      p.turn.from,
+      seen.judgement.verdicts.map((v) => ({
+        key: ruleKey(v.source, v.rule),
+        text: v.text,
+        outcome: LEDGER_OUTCOME[v.outcome],
+        note: v.reasoning ?? ""
+      }))
+    );
+  }
+  try {
+    await writeLedger(file, next);
+  } catch (err) {
+    warn(`could not write the session ledger ${file}: ${firstLine(err)}`);
+  }
+}
+async function judgeTurnOf(p, ledger, seen) {
+  const { config, turn } = p;
+  const conformance = conformanceOf(config);
+  const local = p.localModels ?? libraryLocalModels(config.providers);
+  const report = {
+    trace: p.trace.file,
+    sessionId: p.sessionId,
+    agentId: p.agentId,
+    turn: { from: turn.from, to: turn.to },
+    judge: null,
+    extraction: null,
+    sources: [],
+    findings: [],
+    summary: { sources: 0, rules: 0, notApplicable: 0, fail: 0, needsReview: 0 },
+    session: null,
+    skipped: null,
+    warnings: [...p.trace.warnings],
+    exitCode: 0
+  };
+  const stop = (skipped) => {
+    report.skipped = skipped;
+    return { kind: "report", report };
+  };
+  if (turn.window.empty) return stop("empty-turn");
+  const resolved = await resolveTurnSources(p.trace, turn, {
+    projectDir: p.projectDir,
+    ...p.projectRoot !== void 0 ? { projectRoot: p.projectRoot } : {},
+    ...p.env !== void 0 ? { env: p.env } : {},
+    include: conformance.include,
+    exclude: conformance.exclude,
+    plans: conformance.plans,
+    ...p.agentType !== void 0 ? { agentType: p.agentType } : {}
+  });
+  report.warnings.push(...resolved.warnings);
+  const { sources } = resolved;
+  seen.sources = sources;
+  report.summary.sources = sources.length;
+  if (sources.length === 0) return stop("no-sources");
+  const judgeId = p.judge !== void 0 ? idOf(p.judge) : await resolveSelectionIdentity(config, p.judgeSelection);
+  const judgeIsLocal = judgeId.provider === "llama-cpp";
+  if (p.inLoop && judgeIsLocal) {
+    const skip = await localGate(local, judgeId.model, ["downloading"]);
+    if (skip !== void 0) return { kind: "gate", skip };
+  }
+  const host = hostSetting(p.inLoop, p.sessionId, config.providers["llama-cpp"]?.keepAlive);
+  const ex = await extraction(config, rulesCacheFor(config, p.configDir, p.noCache), p.extractor, host);
+  if (sources.some((s) => ex.needs(s))) {
+    report.extraction = { provider: ex.identity.provider, model: ex.identity.model };
+    if (p.offline && isNetworkProvider(ex.identity.provider)) {
+      throw offlineRefusal("extraction", ex.identity);
+    }
+    if (ex.identity.provider === "llama-cpp") {
+      if (p.inLoop) {
+        const skip = await localGate(
+          local,
+          ex.identity.model,
+          ["downloading", "not-downloaded", "memory"],
+          () => hostHolds(ex.identity.model, p.hostApi)
+        );
+        if (skip !== void 0) return { kind: "gate", skip };
+      } else {
+        await assertDownloaded(local, ex.identity.model);
+      }
+    }
+  }
+  const rules = [];
+  for (const source of sources) {
+    const { rules: found, origin } = await ex.rulesOf(source);
+    report.sources.push({
+      path: source.displayPath,
+      format: source.format,
+      ...source.skill !== void 0 ? { skill: source.skill } : {},
+      trigger: source.trigger,
+      rules: found.length,
+      origin
+    });
+    for (const rule of found) rules.push({ source, rule });
+  }
+  report.summary.rules = rules.length;
+  const { applicable } = applicableRules(rules, turn.window);
+  if (applicable.length === 0) {
+    report.summary.notApplicable = rules.length;
+    return stop("not-applicable");
+  }
+  if (p.offline && isNetworkProvider(judgeId.provider)) {
+    throw offlineRefusal("the judge", judgeId);
+  }
+  const cacheRoot = resolve(p.configDir, config.judge.cacheDir);
+  const limits = new StateLimits(resolve(cacheRoot, "limits"), !p.noCache);
+  const plan = {
+    trace: p.trace,
+    turn,
+    rules,
+    runs: p.runs,
+    temperature: config.judge.temperature,
+    zones: config.judge.zones,
+    render: {
+      maxBlockChars: config.render.maxBlockChars,
+      maxTotalChars: config.render.maxTotalChars,
+      redact: config.judge.redact
+    },
+    ...p.lastAssistantMessage !== void 0 ? { lastAssistantMessage: p.lastAssistantMessage } : {},
+    ledger,
+    project: { cwd: p.projectDir, root: p.projectRoot ?? p.projectDir },
+    cache: new TurnCache(resolve(cacheRoot, "turns"), !p.noCache)
+  };
+  if (judgeIsLocal) {
+    if (p.inLoop) {
+      const skip = await localGate(
+        local,
+        judgeId.model,
+        ["not-downloaded", "memory"],
+        async () => allVerdictsCached({ ...plan, limits }, judgeId) || await hostHolds(judgeId.model, p.hostApi)
+      );
+      if (skip !== void 0) return { kind: "gate", skip };
+    } else {
+      await assertDownloaded(local, judgeId.model);
+    }
+  }
+  markJudgeProcess();
+  const provider = p.judge ?? (judgeId.provider === "mock" ? mockTurnJudge(judgeId.model) : constructProvider(config, judgeId, { host }));
+  let ran;
+  try {
+    ran = await queued(
+      judgeId.model,
+      () => judgeTurn({ ...plan, provider, limits })
+    );
+  } catch (err) {
+    if (err instanceof TracevalsError) throw err;
+    throw new TracevalsError(`could not judge the last turn: ${firstLine(err)}`);
+  }
+  if (ran.busy) {
+    return {
+      kind: "gate",
+      skip: {
+        gate: "busy",
+        message: `tracevals skipped this turn: ${judgeId.model} was busy with other judgements for ${String(QUEUE_WAIT_MS / 6e4)} minutes.`
+      }
+    };
+  }
+  const judgement = ran.value;
+  seen.judgement = judgement;
+  report.judge = {
+    provider: judgeId.provider,
+    model: judgeId.model,
+    mode: judgement.mode,
+    runs: judgement.runs
+  };
+  report.findings = judgement.findings;
+  report.summary.notApplicable = judgement.notApplicable;
+  report.summary.fail = judgement.findings.filter((f) => f.outcome === "fail").length;
+  report.summary.needsReview = judgement.findings.length - report.summary.fail;
+  report.warnings.push(...judgement.warnings);
+  report.exitCode = report.summary.fail > 0 ? 1 : 0;
+  return { kind: "report", report, judgement };
+}
+async function readTrace(path) {
+  try {
+    return await parseTraceFile(path);
+  } catch (err) {
+    throw new TracevalsError(`cannot read trace ${path}: ${firstLine(err)}`);
+  }
+}
+async function runCheck(options) {
+  const { config, dir: configDir } = await discoverConfig(options.configDir ?? process.cwd(), {
+    ...options.config === void 0 ? {} : { configPath: options.config },
+    ...options.noConfig === void 0 ? {} : { noConfig: options.noConfig }
+  });
+  const judgeSelection = selectProvider(config, {
+    ...options.provider !== void 0 ? { provider: options.provider } : {},
+    ...options.model !== void 0 ? { model: options.model } : {},
+    ...options.local !== void 0 ? { local: options.local } : {}
+  });
+  const trace = await readTrace(options.tracePath);
+  const outcome = await conform({
+    config,
+    configDir,
+    trace,
+    turn: lastTurn(trace),
+    sessionId: trace.sessionId ?? basename(trace.file).replace(/\.jsonl$/, ""),
+    agentId: null,
+    projectDir: options.project ?? trace.cwd,
+    ...options.project !== void 0 ? { projectRoot: options.project } : {},
+    ...options.env !== void 0 ? { env: options.env } : {},
+    judgeSelection,
+    runs: options.runs ?? config.judge.ensembleRuns,
+    inLoop: false,
+    noCache: options.noCache === true,
+    offline: options.offline === true,
+    ...seamsOf(options)
+  });
+  if (outcome.kind === "gate") throw new TracevalsError(outcome.skip.message);
+  const { report } = outcome;
+  const rendered = options.format === "json" ? JSON.stringify(report, null, 2) : renderCheck(report, { color: options.color === true });
+  if (options.output !== void 0) await writeFile(options.output, rendered, "utf-8");
+  return { report, rendered };
+}
+function seamsOf(s) {
+  return {
+    ...s.judge !== void 0 ? { judge: s.judge } : {},
+    ...s.extractor !== void 0 ? { extractor: s.extractor } : {},
+    ...s.localModels !== void 0 ? { localModels: s.localModels } : {},
+    ...s.hostApi !== void 0 ? { hostApi: s.hostApi } : {}
+  };
+}
+async function checkTurn(input) {
+  const { config, dir: configDir } = await discoverConfig(input.cwd);
+  if (config.conformance === null) {
+    return { skipped: { gate: "not-in-play" }, findings: [], exitCode: 0 };
+  }
+  const env = input.env ?? process.env;
+  if ((env[JUDGE_ENV] ?? "") !== "") {
+    return { skipped: { gate: "judge-session" }, findings: [], exitCode: 0 };
+  }
+  const subagent = input.agentTranscriptPath !== void 0;
+  const trace = await readTrace(input.agentTranscriptPath ?? input.transcriptPath);
+  const outcome = await conform({
+    config,
+    configDir,
+    trace,
+    turn: subagent ? subagentTurn(trace) : lastTurn(trace),
+    sessionId: input.sessionId,
+    agentId: input.agentId ?? null,
+    ...input.agentType !== void 0 ? { agentType: input.agentType } : {},
+    projectDir: input.cwd,
+    ...input.env !== void 0 ? { env: input.env } : {},
+    judgeSelection: selectHookProvider(config),
+    runs: config.conformance.hook.runs,
+    inLoop: true,
+    noCache: false,
+    offline: false,
+    ...input.lastAssistantMessage !== void 0 ? { lastAssistantMessage: input.lastAssistantMessage } : {},
+    ...seamsOf(input)
+  });
+  if (outcome.kind === "gate") {
+    return { skipped: outcome.skip, findings: [], exitCode: 0 };
+  }
+  const { report, judgement } = outcome;
+  if (report.skipped !== null) {
+    return { skipped: { gate: report.skipped }, findings: [], report, exitCode: 0 };
+  }
+  return {
+    ...judgement !== void 0 ? { judgement } : {},
+    findings: report.findings,
+    report,
+    exitCode: report.exitCode === 1 ? 1 : 0
+  };
+}
+export {
+  checkTurn,
+  runCheck
+};
+//# sourceMappingURL=check-WB2QDHJQ.js.map