@mutagent/evaluator 0.1.0-alpha.5 → 0.2.0-alpha.1

package/.claude/skills/mutagent-evaluator/scripts/run-review.ts

@@ -0,0 +1,266 @@
+/**
+ * run-review — the `*review` RUN COMPOSER.
+ *
+ * WHAT THIS CLOSES. `render-review-report-v3.ts` could render the W4 review surface,
+ * but nothing ASSEMBLED its input: producing the report meant hand-building a
+ * `RenderReviewV3Input` in a session driver. This module reads an existing run
+ * directory — the artifacts `*evaluate` already persists, no new ones — and produces
+ * `review-report.html` beside `evaluation-report.html`. After this, the SYSTEM
+ * produces the review report; a human no longer does.
+ *
+ * It is the analogue of run-evaluate's `writeRunReport` and the discovery composer,
+ * and it reuses their conventions: the same run/report directory layout, the same
+ * strict verdict-file parser, the same "v2 output kept alongside" transition rule.
+ *
+ * ── WHAT IT READS (all pre-existing) ──────────────────────────────────────────
+ *   <runDir>/run-input.full.json   subject · criteria · pin · producedAt, and the
+ *                                  INGESTED trajectories (with their observations,
+ *                                  which give the drill's left lane real tool I/O)
+ *   <runDir>/run-input.json        the same minus the heavy arrays — the fallback,
+ *                                  used only when the full file is absent
+ *   <runDir>/verdicts/*.verdict.json   one judged trajectory each
+ *
+ * `*.verify.json` files live in the same directory and are NOT verdicts (they are
+ * the independent-verify ledger); they are excluded by suffix, not by guesswork.
+ *
+ * ── THE JOIN, AND WHY IT IS NOT THE FILENAME ──────────────────────────────────
+ * A verdict file is named for its PACKET, not its trajectory: `ffc2f7c7.verdict.json`
+ * carries `trajectoryId: "b90818a24afc5069"`. The join is therefore on the parsed
+ * `trajectoryId` — never on the file stem, which would silently produce a report
+ * whose traces match nothing.
+ *
+ * ── HONESTY ───────────────────────────────────────────────────────────────────
+ * An ingested trajectory with no verdict file is NOT silently dropped: the composer
+ * counts it and emits a `scopeNote` naming how many of the ingested trajectories were
+ * judged, which the surface renders as a declared scope reduction. `run-input.json`'s
+ * placeholder strings (it stores `"<5 EvalTraces>"` in place of the arrays) are
+ * detected and treated as ABSENT rather than parsed as data.
+ *
+ * ── DELIBERATELY OUT OF SCOPE — this is NOT W4 ────────────────────────────────
+ * No feedback store, no ruling persistence, no propagation of a ruling into
+ * `*validate`, no calibration application. This module PRODUCES the artifact; it does
+ * not consume a reviewer's answer. That loop is task #9 and is a separate contract.
+ *
+ * PURE except the file reads and the report write.
+ */
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { parseMatrixVerdictFile } from "./contracts/eval-matrix.ts";
+import type { MatrixCriterion, MatrixVerdictFile } from "./contracts/eval-matrix.ts";
+import type { EvalTrace } from "./contracts/eval-types.ts";
+import { runDir as defaultRunDir } from "./artifact-paths.ts";
+import { renderReviewReportV3, writeReviewRunReportV3, type RenderReviewV3Input } from "./render-review-report-v3.ts";
+
+/** the trajectory shape the review surface needs — id plus real observations. */
+interface IngestedTrace {
+  id: string;
+  observations?: { type?: string; name?: string; input?: unknown; output?: unknown }[];
+}
+
+/** the subset of a persisted run-input this composer reads. */
+interface PersistedRunInput {
+  subject?: { name?: string; kind?: string };
+  trajectories?: unknown;
+  criteria?: MatrixCriterion[];
+  subjectProfile?: unknown;
+  pin?: { model?: string; temperature?: number };
+  producedAt?: string;
+}
+
+export interface ReviewRunArgs {
+  runId: string;
+  /** repo root; defaults to process.cwd(). Reports land under its `.mutagent`. */
+  cwd?: string;
+  /** override the run directory (defaults to the standard runs/<runId> path). */
+  runDir?: string;
+  /** see render-review-report-v3: this surface renders identically either way. */
+  audience?: "internal" | "external";
+  devFeedback?: boolean;
+  /** the living-suite version these criteria came from, when known. */
+  suiteVersion?: string;
+  /** appended to the composer's own derived scope note. */
+  scopeNote?: string;
+}
+
+export interface ReviewRunResult {
+  report: string;
+  fallback: string | null;
+  runId: string;
+  trajectoriesIngested: number;
+  trajectoriesJudged: number;
+  verdicts: number;
+  criteria: number;
+  /** verdict files whose trajectoryId matched no ingested trajectory. */
+  unjoinedTrajectoryIds: string[];
+}
+
+/** `run-input.json` stores `"<5 EvalTraces>"` where the full file stores the array. */
+function asArray<T>(v: unknown): T[] | null {
+  return Array.isArray(v) ? (v as T[]) : null;
+}
+
+/** Read the persisted run-input, preferring the full file. FAIL-LOUD when neither exists. */
+function readRunInput(dir: string): { data: PersistedRunInput; path: string } {
+  for (const name of ["run-input.full.json", "run-input.json"]) {
+    const p = join(dir, name);
+    if (existsSync(p)) return { data: JSON.parse(readFileSync(p, "utf8")) as PersistedRunInput, path: p };
+  }
+  throw new Error(
+    `run-review: no run-input.full.json or run-input.json in '${dir}'. ` +
+      "The review surface is composed from an EXISTING *evaluate run — point it at a run directory that has one.",
+  );
+}
+
+/** Every `*.verdict.json` in the run's verdict dir, parsed strictly. */
+function readVerdictFiles(dir: string): MatrixVerdictFile[] {
+  const vdir = join(dir, "verdicts");
+  if (!existsSync(vdir)) throw new Error(`run-review: no verdicts/ directory in '${dir}' — nothing has been judged for this run.`);
+  // `.verify.json` is the independent-verify ledger, NOT a verdict — excluded by
+  // suffix so a future sibling artifact cannot silently be parsed as a verdict.
+  const names = readdirSync(vdir).filter((f) => f.endsWith(".verdict.json")).sort();
+  if (names.length === 0) throw new Error(`run-review: no *.verdict.json files in '${vdir}' — nothing has been judged for this run.`);
+  return names.map((n) => {
+    try {
+      return parseMatrixVerdictFile(readFileSync(join(vdir, n), "utf8"));
+    } catch (e) {
+      // name the FILE — a schema violation with no filename is unactionable when
+      // a run carries dozens of verdicts.
+      throw new Error(`run-review: ${n} is not a valid verdict file — ${String((e as Error).message).slice(0, 200)}`);
+    }
+  });
+}
+
+/**
+ * Assemble a `RenderReviewV3Input` from a run directory. Pure apart from the reads,
+ * and exported so the composition can be asserted without writing a report.
+ */
+export function readReviewRunInput(args: ReviewRunArgs): { input: RenderReviewV3Input; stats: Omit<ReviewRunResult, "report" | "fallback"> } {
+  const dir = args.runDir ?? defaultRunDir(args.runId, args.cwd);
+  if (!existsSync(dir)) throw new Error(`run-review: run directory not found: '${dir}'`);
+  const { data } = readRunInput(dir);
+
+  const criteria = asArray<MatrixCriterion>(data.criteria);
+  if (criteria === null || criteria.length === 0)
+    throw new Error(`run-review: the run-input in '${dir}' carries no criteria array — the review surface has nothing to show rows for.`);
+
+  const files = readVerdictFiles(dir);
+  // the full run-input holds real trajectories; the lean one holds a placeholder
+  // STRING, which must read as absent rather than be coerced into a trace list.
+  const ingested = asArray<IngestedTrace>(data.trajectories) ?? [];
+  const ingestedIds = new Set(ingested.map((t) => t.id));
+  const judgedIds = new Set(files.map((f) => f.trajectoryId));
+  const unjoined = [...judgedIds].filter((id) => !ingestedIds.has(id));
+
+  // NAMED scope: an ingested-but-unjudged trajectory is declared, never dropped.
+  const notes: string[] = [];
+  if (ingested.length > 0 && judgedIds.size < ingested.length)
+    notes.push(`${judgedIds.size} of ${ingested.length} ingested trajectories carry a judge verdict; the rest are not shown`);
+  if (ingested.length === 0)
+    notes.push("the run-input carried no trajectory array, so the drill shows the judge's own step record rather than raw tool I/O");
+  if (unjoined.length > 0)
+    notes.push(`${unjoined.length} verdict file(s) reference a trajectory absent from the run-input (${unjoined.join(", ")})`);
+  if (args.scopeNote !== undefined) notes.push(args.scopeNote);
+
+  const input: RenderReviewV3Input = {
+    subjectName: data.subject?.name ?? args.runId,
+    runId: args.runId,
+    audience: args.audience ?? "internal",
+    criteria,
+    files,
+    ...(ingested.length > 0 ? { traces: ingested } : {}),
+    ...(data.subjectProfile !== undefined && typeof data.subjectProfile === "object" && data.subjectProfile !== null
+      ? { subjectProfile: data.subjectProfile as Record<string, unknown> }
+      : {}),
+    pin: { model: data.pin?.model ?? "(judge model not recorded in the run-input)", temperature: 0 },
+    ...(data.producedAt !== undefined ? { generatedAt: data.producedAt } : {}),
+    ...(args.suiteVersion !== undefined ? { suiteVersion: args.suiteVersion } : {}),
+    ...(notes.length > 0 ? { scopeNote: notes.join(" · ") } : {}),
+    ...(args.devFeedback !== undefined ? { devFeedback: args.devFeedback } : {}),
+  };
+
+  return {
+    input,
+    stats: {
+      runId: args.runId,
+      trajectoriesIngested: ingested.length,
+      trajectoriesJudged: judgedIds.size,
+      verdicts: files.reduce((a, f) => a + f.verdicts.length, 0),
+      criteria: criteria.length,
+      unjoinedTrajectoryIds: unjoined,
+    },
+  };
+}
+
+/**
+ * THE COMPOSER — read a run directory and write `review-report.html` (plus the v1
+ * `review-report.v2.html` fallback when the run carries ingested traces the v1 UI
+ * can consume). Returns the paths and what was actually composed.
+ */
+export function writeReviewRunReport(args: ReviewRunArgs): ReviewRunResult {
+  const { input, stats } = readReviewRunInput(args);
+  const repoRoot = args.cwd ?? process.cwd();
+  // the v1 annotation UI consumes EvalTrace[]; the ingested trajectories ARE that
+  // shape in a persisted run-input. Absent ⇒ no fallback is written and the result
+  // says so with `fallback: null`, rather than an empty file pretending to be one.
+  const evalTraces = (input.traces ?? []) as unknown as EvalTrace[];
+  const { report, fallback } = writeReviewRunReportV3(input, repoRoot, evalTraces.length > 0 ? evalTraces : undefined);
+  return { ...stats, report, fallback };
+}
+
+/** Render without writing — for tests and for callers that want the HTML in hand. */
+export function renderReviewRunReport(args: ReviewRunArgs): string {
+  return renderReviewReportV3(readReviewRunInput(args).input);
+}
+
+/* ── CLI entrypoint ────────────────────────────────────────────────────────────
+ *
+ *   bun scripts/run-review.ts <runId> [--cwd <repoRoot>] [--run-dir <dir>]
+ *                                     [--suite <version>] [--dev-feedback]
+ *
+ * This is the production caller the `*review` command's parent Bash invokes, mirroring
+ * build-review-ui.ts's CLI. Costs nothing: it reads artifacts an `*evaluate` run has
+ * already produced and dispatches no judge.
+ */
+declare const Bun: { argv: string[] } | undefined;
+
+function parseArgv(argv: string[]): ReviewRunArgs | null {
+  const [runId] = argv;
+  if (runId === undefined || runId.startsWith("--")) return null;
+  const flag = (name: string): string | undefined => {
+    const i = argv.indexOf(`--${name}`);
+    return i >= 0 ? argv[i + 1] : undefined;
+  };
+  const cwd = flag("cwd");
+  const rd = flag("run-dir");
+  const suite = flag("suite");
+  return {
+    runId,
+    ...(cwd !== undefined ? { cwd } : {}),
+    ...(rd !== undefined ? { runDir: rd } : {}),
+    ...(suite !== undefined ? { suiteVersion: suite } : {}),
+    ...(argv.includes("--dev-feedback") ? { devFeedback: true } : {}),
+  };
+}
+
+async function main(): Promise<void> {
+  const argv = typeof Bun !== "undefined" ? Bun.argv.slice(2) : process.argv.slice(2);
+  const args = parseArgv(argv);
+  if (args === null) {
+    console.error("usage: run-review.ts <runId> [--cwd <repoRoot>] [--run-dir <dir>] [--suite <version>] [--dev-feedback]");
+    process.exit(2);
+    return;
+  }
+  const r = writeReviewRunReport(args);
+  console.info(
+    `review report written: ${r.report}\n` +
+      `  ${r.trajectoriesJudged}/${r.trajectoriesIngested || r.trajectoriesJudged} trajectories judged · ` +
+      `${r.verdicts} judge verdicts · ${r.criteria} criteria` +
+      (r.fallback !== null ? `\n  v1 fallback: ${r.fallback}` : "\n  v1 fallback: not written (the run carries no ingested traces)") +
+      (r.unjoinedTrajectoryIds.length > 0 ? `\n  WARNING: ${r.unjoinedTrajectoryIds.length} verdict(s) reference an unknown trajectory` : ""),
+  );
+  process.exit(0);
+}
+
+if (typeof Bun !== "undefined" && Bun.argv[1]?.endsWith("run-review.ts") === true) {
+  await main();
+}

package/.claude/skills/mutagent-evaluator/scripts/subject-profile.ts

@@ -22,11 +22,62 @@
 import {
   PROFILE_UNKNOWN,
   SubjectProfileProvenance,
+  ToolReversibility,
   type SubjectProfile,
+  type ToolReversibilityEntry,
+  type ToolReversibilityValue,
 } from "./contracts/eval-matrix.ts";
 import { inferToolInventory, inferSystemPrompt } from "./profile-subject.ts";
 import type { EvalTrace } from "./contracts/eval-types.ts";
 
+// ── EV-5 — tool reversibility classification ─────────────────────────────────
+//
+// LEAN start (operator: "classify its tools by what they do — irreversible external
+// or not; keep the start lean"). A GIVEN classification (from the subject definition)
+// ALWAYS wins; absent, a conservative NAME heuristic flags well-known irreversible-
+// external verbs and well-known read-only verbs, and marks everything else `unknown`
+// (HONEST — never a false "reversible"). The heavier per-trace side-effect harness
+// (decision option b) can supersede this later without changing the field shape.
+
+/** Verb stems whose presence in a tool name signals an IRREVERSIBLE EXTERNAL action. */
+const IRREVERSIBLE_VERBS = [
+  "send", "email", "post", "publish", "delete", "remove", "destroy", "drop",
+  "charge", "pay", "refund", "transfer", "deploy", "release", "submit", "create",
+  "insert", "write", "update", "patch", "put", "execute", "provision", "terminate",
+  "cancel", "notify", "dispatch", "message", "reply", "comment", "merge", "push",
+];
+/** Verb stems whose presence signals a READ-ONLY / safely-repeatable action. */
+const REVERSIBLE_VERBS = [
+  "get", "list", "read", "search", "fetch", "lookup", "view", "query", "find",
+  "check", "inspect", "describe", "count", "peek", "preview", "validate",
+];
+
+/**
+ * Classify one tool's reversibility (EV-5). A GIVEN `override` (subject definition)
+ * wins; else a conservative name heuristic — irreversible-external verbs first (the
+ * safety-relevant class), then read-only verbs, else `unknown` (never guessed). PURE.
+ */
+export function classifyToolReversibility(
+  name: string,
+  override?: Record<string, ToolReversibilityValue>,
+): ToolReversibilityValue {
+  const given = override?.[name];
+  if (given !== undefined) return given;
+  const n = name.toLowerCase();
+  const hits = (verbs: string[]): boolean => verbs.some((v) => n.includes(v));
+  if (hits(IRREVERSIBLE_VERBS)) return ToolReversibility.IrreversibleExternal;
+  if (hits(REVERSIBLE_VERBS)) return ToolReversibility.Reversible;
+  return ToolReversibility.Unknown;
+}
+
+/** Classify every tool in the inventory (EV-5). Deterministic; preserves order. */
+export function classifyToolList(
+  tools: string[],
+  override?: Record<string, ToolReversibilityValue>,
+): ToolReversibilityEntry[] {
+  return tools.map((name) => ({ name, reversibility: classifyToolReversibility(name, override) }));
+}
+
 /** The GIVEN facts a caller with code/metadata access can supply (M1). Any field
  *  left absent is RECONSTRUCTED from the trace batch or MARKED `unknown`. */
 export interface GivenSubjectFacts {
@@ -41,6 +92,9 @@ export interface GivenSubjectFacts {
   version?: string;
   /** the agent's system prompt (code access). Rendered COLLAPSED; never confabulated. */
   systemPrompt?: string;
+  /** EV-5 — a GIVEN per-tool reversibility classification (from the subject definition);
+   *  WINS over the name heuristic. Any tool not named here falls back to the heuristic. */
+  toolReversibility?: Record<string, ToolReversibilityValue>;
 }
 
 export interface BuildSubjectProfileParams {
@@ -117,10 +171,14 @@ export function buildSubjectProfile(params: BuildSubjectProfileParams): SubjectP
   if (systemPrompt === undefined) systemPrompt = inferSystemPrompt(traces);
   if (given?.systemPrompt === undefined) inferredFields.push("systemPrompt");
 
+  // EV-5 — classify each tool's reversibility (GIVEN override wins; else name heuristic).
+  const toolReversibility = classifyToolList(tools, given?.toolReversibility);
+
   const profile: SubjectProfile = {
     identity,
     purpose,
     tools,
+    toolReversibility,
     scope,
     harness,
     provenance: hasGiven ? SubjectProfileProvenance.Given : SubjectProfileProvenance.Reconstructed,
@@ -132,3 +190,27 @@ export function buildSubjectProfile(params: BuildSubjectProfileParams): SubjectP
   };
   return profile;
 }
+
+/** The compact determiner subject frame (EV-1) — a structural subset of the M1 profile. */
+export interface SubjectFrameShape {
+  identity: string;
+  purpose: string;
+  tools: string[];
+  toolReversibility?: ToolReversibilityEntry[];
+}
+
+/**
+ * Derive the determiner/judge subject frame (EV-1 / EV-5) from a subject name + trace
+ * batch. THE single derivation used by run-pipeline (Stage-B) AND prep (Stage-A) so
+ * the determiner prompt is byte-identical across the two stages (the cross-stage cache
+ * would miss on any divergence). PURE — same inputs ⇒ same frame.
+ */
+export function deriveSubjectFrame(subjectName: string, traces: EvalTrace[]): SubjectFrameShape {
+  const m1 = buildSubjectProfile({ subjectName, traces });
+  return {
+    identity: m1.identity,
+    purpose: m1.purpose,
+    tools: m1.tools,
+    ...(m1.toolReversibility !== undefined ? { toolReversibility: m1.toolReversibility } : {}),
+  };
+}

package/.claude/skills/mutagent-evaluator/scripts/sync-eval-criteria.ts

@@ -2,7 +2,7 @@
  * scripts/sync-eval-criteria.ts — the EVAL-LEG reconcile CONTRACT (Wave-2 W2I5 · KP-003).
  * ---------------------------------------------------------------------------
  * The THIRD leg of the def → impl → eval triad. Today `#sync-spec` reconciles two
- * legs — spec ↔ impl. When an implementation amends (the ⑤ IMPROVE loop's ai-engineer,
+ * legs — spec ↔ impl. When an implementation amends (the ⑤ OPTIMIZE loop's ai-engineer,
  * or a brownfield drift), the eval criteria that GROUND the subject's evaluation can go
  * stale w.r.t. the changed impl. This module is the EVALUATOR-SIDE CONTRACT that the
  * reconcile (ai-architect REASONING, session-dispatched — Model-B) READS and WRITES:
@@ -35,7 +35,7 @@ import { assertMonotonicGrowth } from "./living-suite.ts";
 // ── subject kind → eval leg ──────────────────────────────────────────────────
 
 /** The subject kinds the triad reconciles. `agent|skill|composite` come from the
- *  agentspec `definition.identity.kind`; `code` is the ⑤ IMPROVE code-target subject. */
+ *  agentspec `definition.identity.kind`; `code` is the ⑤ OPTIMIZE code-target subject. */
 export const EvalSubjectKind = {
   Agent: "agent",
   Skill: "skill",

package/.claude/skills/mutagent-evaluator/scripts/unitf-to-evaltrace.ts

@@ -164,6 +164,34 @@ function effectiveRole(span: UnitfSpan): UnitfRole {
   }
 }
 
+// ── Message-text pick (INF-1) ────────────────────────────────────────────────
+//
+// ROOT CAUSE of the Claude Code loss: the Claude Code exporter writes BOTH user
+// and assistant TEXT into `span.output` (a user turn is `kind:"event", role:"user",
+// output:<text>`; an assistant turn is `kind:"llm", role:"assistant", output:<text>`
+// with `input` UNSET). The old projection read a user/system span's `.input` — empty
+// for EVERY Claude Code trace ⇒ `input.prompt` silently empty for all 21/21.
+//
+// This VENDORS the shared reader's role-conditional pick + fallback
+// (@mutagent/tools `messagesView`, derive.ts:173-174): a user/system turn's text is
+// canonically in `input`, everything else in `output`, but the `?? input ?? output`
+// fallback recovers the text WHICHEVER field a producer used. Vendored — never
+// imported: the standalone-publish guard forbids the evaluator reaching into
+// @mutagent/tools (MIGRATION-diagnostics-evaluator.md:417); diagnostics vendors its
+// own copy and this mirrors that.
+
+/**
+ * The span's effective message TEXT: the role-conditional field pick with the
+ * `?? input ?? output` fallback (mirrors @mutagent/tools `messagesView`). Recovers
+ * a Claude Code turn (text in `output`) AND a Langfuse turn (text in `input`).
+ * PURE; "" when the span carries no text.
+ */
+function messageText(span: UnitfSpan): string {
+  const role = effectiveRole(span);
+  const primary = role === "user" || role === "system" ? span.input : span.output;
+  return asText(primary ?? span.input ?? span.output);
+}
+
 // ── Token total fallback (XF-FIX Finding D) ──────────────────────────────────
 //
 // MIRRORS diagnostics `unitf-adapter.ts` `fallbackTotalTokens` so both lanes
@@ -185,10 +213,11 @@ function fallbackTotalTokens(t: UnitfTokens | undefined): number | undefined {
  *
  *   id               ← ut.traceId
  *   name             ← ut.agentName
- *   output           ← first EFFECTIVE-assistant llm span → { response: <text of span.output> }
- *                      (XF-FIX A: role-less GENERATION spans read as assistant via kind)
- *   input            ← first user|system span's input, ELSE the response span's own
- *                      input → { prompt } (XF-FIX A: recovers the Langfuse prompt)
+ *   output           ← LAST EFFECTIVE-assistant llm span WITH text → { response: <messageText> }
+ *                      (XF-FIX A: role-less GENERATION spans read as assistant via kind;
+ *                       INF-1: last-with-text, and messageText recovers Claude Code's `output`)
+ *   input            ← first user|system span's messageText, ELSE the response span's own
+ *                      input → { prompt } (XF-FIX A: Langfuse prompt; INF-1: Claude Code `output`)
  *   observations     ← ut.spans → { type: kind.toUpperCase(), name, input, output }
  *   errored/status   ← computed.hasError ?? (status==="error" || any span error) / ut.status (XF-FIX C)
  *   tokens/totalTokens← ut.tokens split / computed.totalTokens ?? tokens.total ?? in+out (XF-FIX D)
@@ -216,31 +245,45 @@ export function projectUnitfToEvalTrace(ut: UnifiedTraceLike): EvalTrace {
 
   if (ut.agentName !== undefined) out.name = ut.agentName;
 
-  // output ← first assistant LLM span's output, wrapped to { response }. The
-  // assistant role is now EFFECTIVE (XF-FIX Finding A): a role-less GENERATION
-  // span (kind==="llm", the Langfuse shape) reads as assistant via `effectiveRole`,
-  // so its output is picked up instead of being silently dropped.
-  const responseSpan = ut.spans.find(
+  // output ← the LAST assistant LLM span WITH text, wrapped to { response }. The
+  // assistant role is EFFECTIVE (XF-FIX Finding A): a role-less GENERATION span
+  // (kind==="llm", the Langfuse shape) reads as assistant via `effectiveRole`. The
+  // second INF-1 miss: the old code took the FIRST assistant span — on Claude Code
+  // that is usually a tool_use turn with EMPTY output text, so the real reply (a
+  // LATER assistant span) was dropped. Take the LAST assistant span that carries
+  // text; the `messageText` pick recovers it from `output` (Claude Code) or `input`
+  // (whichever field the producer used).
+  const assistantSpans = ut.spans.filter(
     (s) => effectiveRole(s) === "assistant" && s.kind === "llm",
   );
-  if (responseSpan !== undefined && responseSpan.output !== undefined) {
-    out.output = { response: asText(responseSpan.output) };
+  let responseSpan: UnitfSpan | undefined;
+  for (const s of assistantSpans) {
+    if (messageText(s).length > 0) responseSpan = s; // keep the LAST with text
+  }
+  // Fall back to the last assistant span even without text, so the response SLOT is
+  // still derived from a real span (the empty case is WARNED at intake, not here).
+  const lastAssistant =
+    responseSpan ?? (assistantSpans.length > 0 ? assistantSpans[assistantSpans.length - 1] : undefined);
+  if (responseSpan !== undefined) {
+    out.output = { response: messageText(responseSpan) };
   }
 
-  // input ← first user|system span's input, wrapped to { prompt }. A role-less
-  // span never infers to user/system, so when there is no explicit user/system
-  // turn (again the Langfuse shape — one GENERATION span carrying prompt in its
-  // OWN `input` and response in `output`) the prompt is recovered from the
-  // response span's `input`. Without this fallback `input.prompt` was empty for
-  // EVERY Langfuse trace (Finding A).
+  // input ← the first user|system span's TEXT, wrapped to { prompt }. `messageText`
+  // recovers the text from `output` (Claude Code writes the user turn there) or
+  // `input` (Langfuse). When there is no explicit user/system turn (the Langfuse
+  // shape — one GENERATION span carrying the prompt in its OWN `input` and the
+  // response in `output`) the prompt is recovered from the response span's `input`
+  // SPECIFICALLY (not `messageText`, which for an assistant span would return the
+  // response). Without these fallbacks `input.prompt` was empty for every Claude
+  // Code trace (INF-1) and every Langfuse trace (Finding A).
   const promptSpan = ut.spans.find(
     (s) => effectiveRole(s) === "user" || effectiveRole(s) === "system",
   );
-  if (promptSpan !== undefined && promptSpan.input !== undefined) {
-    out.input = { prompt: asText(promptSpan.input) };
-  } else if (responseSpan !== undefined && responseSpan.input !== undefined) {
-    out.input = { prompt: asText(responseSpan.input) };
+  let promptText = promptSpan !== undefined ? messageText(promptSpan) : "";
+  if (promptText.length === 0 && lastAssistant !== undefined && lastAssistant.input !== undefined) {
+    promptText = asText(lastAssistant.input);
   }
+  if (promptText.length > 0) out.input = { prompt: promptText };
 
   // Finding C — carry structured error/status so an error-KIND criterion has a
   // field to read (previously error state survived only as textual span output).