@mutagent/evaluator 0.1.0-alpha.4 → 0.1.0-alpha.6

package/.claude/skills/mutagent-evaluator/scripts/code-quality-verdict.ts

@@ -0,0 +1,277 @@
+/**
+ * scripts/code-quality-verdict.ts — the CODE-QUALITY judge mode (Wave-2 W2I1).
+ * ---------------------------------------------------------------------------
+ * A JUDGE mode that scores a CODE subject's QUALITY (the amended/scaffolded
+ * implementation of a `code`-kind subject) and emits a binary PASS/FAIL quality
+ * verdict with a critique-before-verdict per criterion. It is the (b) half of the
+ * ⑤ OPTIMIZE loop's code-target BOTH-gate: "converged" for a `code` subject = the
+ * subject's OWN test suite green (a deterministic gate the session records as
+ * `testsGreen`) AND this code-quality verdict PASSes. Neither alone converges.
+ *
+ * DISTINCT FROM `code-eval.ts`. That file is the DETERMINISTIC code-track primitive
+ * library (presence/string-equality/... over an EvalTrace — no LLM, byte-identical).
+ * This file is an LLM JUDGE mode: it scores the irreducibly-subjective quality of a
+ * code implementation (spec-faithfulness, maintainability, error-handling, ...) that
+ * a deterministic primitive cannot decide.
+ *
+ * INVARIANTS (consistent with the existing evaluator cell):
+ *   - JUDGE-ONLY (EV-051). It scores; it NEVER fixes. Failures route to the ⑤ loop's
+ *     ai-engineer amend (via the loop, not from here).
+ *   - HOST-RUNTIME. Under the DEFAULT agent-dispatch substrate the authoritative
+ *     rubric lives in the evaluator agent def (`#mode-judge-code-quality`), and the
+ *     verdict comes from a dispatched subagent — this file's prompt is the
+ *     provider-callable MIRROR for the OPTIONAL in-house / export substrate (same
+ *     operator-named exception as judge-prompt-template.ts). No provider key on the
+ *     default path.
+ *   - PINNED model + temperature 0 (C-PIN). `runCodeQualityJudge` THROWS if the pin
+ *     is not (modelId present AND temperature === 0) — reruns must be byte-identical.
+ *   - PURE renderer + a thin injected-seam run wrapper. No clock, no random, no
+ *     network; the LLM call is the injected `JudgeInvoke` seam so tests drive it.
+ */
+import { readFileSync } from "node:fs";
+import { fileURLToPath, URL } from "node:url";
+import { parse as parseYaml } from "yaml";
+import { parseCritiqueVerdict, type JudgeInvoke } from "./determine-outcome.ts";
+import type { JudgePin } from "./build-evals.ts";
+import type { CritiqueVerdict } from "./contracts/eval-types.ts";
+
+/** Severity of a code-quality criterion — gates the aggregate (CRIT/HIGH block). */
+export const CodeQualitySeverity = {
+  Critical: "critical",
+  High: "high",
+  Medium: "medium",
+} as const;
+export type CodeQualitySeverityValue =
+  (typeof CodeQualitySeverity)[keyof typeof CodeQualitySeverity];
+
+/** One binary code-quality criterion the judge scores. */
+export interface CodeQualityCriterion {
+  /** Stable id (byte-identity key + report anchor). */
+  id: string;
+  /** The one-line binary statement the judge decides pass/fail on. */
+  statement: string;
+  /** What a PASS looks like (concrete, so the judge is not guessing). */
+  passDefinition: string;
+  /** What a FAIL looks like. */
+  failDefinition: string;
+  /** Gating weight — a `fail`/`uncertain` on a CRIT/HIGH criterion blocks the gate. */
+  severity: CodeQualitySeverityValue;
+}
+
+/**
+ * ⚠️ FLAGGED-FOR-OPERATOR-SIGN-OFF (Wave-2 W2I1). The DRAFT default set of acceptance
+ * criteria that define "code quality-pass" BEYOND tests-green.
+ *
+ * The rubric itself now lives in `../assets/code-quality-criteria.yaml` — a versioned,
+ * operator-editable ARTIFACT — so the criteria + severities can be tuned WITHOUT a code
+ * change (FU-61.1). This module only LOADS and VALIDATES it; the shape/aggregation stay
+ * in code. Ids/statements/severities are unchanged from the original inline set.
+ *
+ * Aggregation (also FLAGGED, still in code): severity-gated — a `fail` OR `uncertain`
+ * on any CRITICAL/HIGH criterion blocks the quality-pass; MEDIUM is advisory.
+ *
+ * Fail-loud: a malformed/missing rubric THROWS at import. There is no silent fallback —
+ * a broken rubric must never quietly degrade the gate.
+ */
+const CODE_QUALITY_CRITERIA_PATH = fileURLToPath(
+  new URL("../assets/code-quality-criteria.yaml", import.meta.url),
+);
+
+const VALID_SEVERITIES: readonly string[] = Object.values(CodeQualitySeverity);
+
+/** Parse + validate the rubric artifact. PURE given the file; THROWS on any defect. */
+export function parseCodeQualityCriteria(raw: string, source = CODE_QUALITY_CRITERIA_PATH): readonly CodeQualityCriterion[] {
+  // NOTE: a function DECLARATION (not a const arrow) so TS narrows through the
+  // never-returning calls below — control-flow analysis requires this form.
+  function bad(msg: string): never {
+    throw new Error(`code-quality rubric invalid (${source}): ${msg}`);
+  }
+  const doc = parseYaml(raw) as { version?: unknown; criteria?: unknown } | null;
+  if (doc === null || typeof doc !== "object") bad("not a YAML mapping");
+  if (typeof doc.version !== "number") bad("`version` must be a number");
+  if (!Array.isArray(doc.criteria) || doc.criteria.length === 0) bad("`criteria` must be a non-empty list");
+
+  const seen = new Set<string>();
+  const out = (doc.criteria as unknown[]).map((c, i) => {
+    const at = `criteria[${i}]`;
+    if (c === null || typeof c !== "object") return bad(`${at} is not a mapping`);
+    const r = c as Record<string, unknown>;
+    for (const k of ["id", "statement", "passDefinition", "failDefinition", "severity"]) {
+      if (typeof r[k] !== "string" || (r[k] as string).trim() === "") bad(`${at}.${k} must be a non-empty string`);
+    }
+    const id = r.id as string;
+    if (seen.has(id)) bad(`${at}.id "${id}" is duplicated`);
+    seen.add(id);
+    if (!VALID_SEVERITIES.includes(r.severity as string)) {
+      bad(`${at}.severity "${String(r.severity)}" must be one of ${VALID_SEVERITIES.join(" | ")}`);
+    }
+    return {
+      id,
+      statement: r.statement as string,
+      passDefinition: r.passDefinition as string,
+      failDefinition: r.failDefinition as string,
+      severity: r.severity as CodeQualitySeverityValue,
+    } satisfies CodeQualityCriterion;
+  });
+  return Object.freeze(out);
+}
+
+export const DEFAULT_CODE_QUALITY_CRITERIA: readonly CodeQualityCriterion[] =
+  parseCodeQualityCriteria(readFileSync(CODE_QUALITY_CRITERIA_PATH, "utf8"));
+
+/** The code subject under quality review (minimal, subject-agnostic). */
+export interface CodeQualitySubject {
+  /** Subject id (spec_id / target name) — provenance only. */
+  subjectId: string;
+  /** The target framework/harness the impl was built into (context for the judge). */
+  framework: string;
+  /** A compact summary of the agentspec DEFINITION the impl must realize (the SSoT). */
+  specSummary: string;
+  /** The applied change under review — the amend diff, or the scaffold summary. */
+  appliedChange: string;
+  /**
+   * The diagnosed root-cause / remedy locus this change was meant to address (feeds
+   * Q2). Empty for a fresh scaffold with no prior diagnosis.
+   */
+  diagnosisLocus?: string;
+}
+
+/** One criterion's judged result (critique-before-verdict, binary). */
+export interface CodeQualityCriterionVerdict {
+  criterionId: string;
+  severity: CodeQualitySeverityValue;
+  result: CritiqueVerdict["result"]; // pass | fail | uncertain
+  critique: string;
+  confidence: number;
+}
+
+/** The aggregated code-quality verdict for one subject. */
+export interface CodeQualityVerdict {
+  subjectId: string;
+  /** The binary quality gate — the (b) half of the ⑤ code-target BOTH-gate. */
+  pass: boolean;
+  perCriterion: CodeQualityCriterionVerdict[];
+  /** C-PIN provenance stamped on the verdict (byte-identity guarantee). */
+  pinned: JudgePin;
+}
+
+/**
+ * Render the code-quality judge prompt for ONE criterion — the provider-callable
+ * mirror of the `#mode-judge-code-quality` rubric. Critique-BEFORE-verdict, strictly
+ * BINARY (no Likert), judge-only. No decision is made here.
+ */
+export function buildCodeQualityPrompt(
+  criterion: CodeQualityCriterion,
+  subject: CodeQualitySubject,
+): { system: string; user: string } {
+  const system = [
+    "You are a BINARY Pass/Fail code-QUALITY judge for ONE criterion of a CODE",
+    "subject (an agent/tooling implementation). Judge exactly this criterion and",
+    "nothing else. You are a JUDGE ONLY — you NEVER propose or write a fix.",
+    "",
+    "Quality is assessed BEYOND the subject's test suite (tests-green is a separate",
+    "deterministic gate). Judge the code as written against the criterion.",
+    "",
+    `Criterion (${criterion.id}, severity ${criterion.severity}): ${criterion.statement}`,
+    criterion.passDefinition,
+    criterion.failDefinition,
+    "",
+    "Outcomes are strictly BINARY: pass or fail (use uncertain ONLY when the change",
+    "genuinely lacks the evidence to decide). NO Likert scales, NO 1-5 / letter",
+    "grades, NO partial credit.",
+    "",
+    "Output STRICT JSON with the critique BEFORE the verdict (reason first, then",
+    "commit):",
+    '{ "critique": "<evidence-citing assessment>", "result": "pass"|"fail"|"uncertain",',
+    '  "confidence": <0..1> }',
+  ].join("\n");
+
+  const user = [
+    `Subject: ${subject.subjectId}  ·  target framework: ${subject.framework}`,
+    "",
+    "Agentspec definition the implementation must realize (the SSoT):",
+    subject.specSummary,
+    "",
+    subject.diagnosisLocus !== undefined && subject.diagnosisLocus.length > 0
+      ? `Diagnosed root-cause / remedy locus (for the addresses-diagnosis check):\n${subject.diagnosisLocus}\n`
+      : "",
+    "Applied change under review (diff or scaffold summary):",
+    subject.appliedChange,
+  ]
+    .filter((l) => l !== "")
+    .join("\n");
+
+  return { system, user };
+}
+
+/**
+ * The PURE aggregation: severity-gate the per-criterion verdicts into ONE binary
+ * quality-pass. FLAGGED default rule — a `fail` OR `uncertain` on any CRITICAL/HIGH
+ * criterion blocks the pass; MEDIUM is advisory (never blocks). Deterministic.
+ */
+export function codeQualityGatePass(
+  perCriterion: readonly CodeQualityCriterionVerdict[],
+): boolean {
+  for (const v of perCriterion) {
+    const gating =
+      v.severity === CodeQualitySeverity.Critical || v.severity === CodeQualitySeverity.High;
+    if (gating && v.result !== "pass") return false;
+  }
+  return true;
+}
+
+/**
+ * Run the code-quality judge over the criteria set under a PINNED model. THROWS if
+ * the pin is not (modelId present AND temperature === 0) — C-PIN (byte-identical
+ * reruns). Renders each criterion → the injected `JudgeInvoke` seam → parses
+ * (critique-before-verdict) → severity-gated aggregate. Under the DEFAULT
+ * agent-dispatch substrate the verdicts instead come from a dispatched
+ * `#mode-judge-code-quality` subagent (verdict files) and this wrapper is not used.
+ * Deterministic given (subject, judge, pin, criteria).
+ */
+export async function runCodeQualityJudge(
+  subject: CodeQualitySubject,
+  judge: JudgeInvoke,
+  pin: JudgePin,
+  criteria: readonly CodeQualityCriterion[] = DEFAULT_CODE_QUALITY_CRITERIA,
+): Promise<CodeQualityVerdict> {
+  if (typeof pin.modelId !== "string" || pin.modelId.length === 0) {
+    throw new Error(
+      "runCodeQualityJudge: judge is not pinned (missing modelId). MODEL INTENT IS " +
+        "SACRED — a non-pinned judge can never produce a verdict (C-PIN).",
+    );
+  }
+  if (pin.temperature !== 0) {
+    throw new Error(
+      `runCodeQualityJudge: judge temperature=${pin.temperature} (!= 0) — not pinned. ` +
+        "MODEL INTENT IS SACRED: reruns must be byte-identical (C-PIN); refusing.",
+    );
+  }
+  if (criteria.length === 0) {
+    throw new Error(
+      "runCodeQualityJudge: empty criteria set — a code-quality verdict with no " +
+        "criteria would vacuously pass (a false-green). Refusing.",
+    );
+  }
+
+  const perCriterion: CodeQualityCriterionVerdict[] = [];
+  for (const criterion of criteria) {
+    const { system, user } = buildCodeQualityPrompt(criterion, subject);
+    const raw = await judge(system, user);
+    const v = parseCritiqueVerdict(raw);
+    perCriterion.push({
+      criterionId: criterion.id,
+      severity: criterion.severity,
+      result: v.result,
+      critique: v.critique,
+      confidence: v.confidence,
+    });
+  }
+
+  return {
+    subjectId: subject.subjectId,
+    pass: codeQualityGatePass(perCriterion),
+    perCriterion,
+    pinned: { modelId: pin.modelId, temperature: pin.temperature },
+  };
+}

package/.claude/skills/mutagent-evaluator/scripts/config/schema.ts

@@ -235,9 +235,9 @@ export type GlobalSource = Static<typeof GlobalSourceSchema>;
 
 /**
  * A precise link to an Agent / Tooling definition file in a code target.
- * RESERVED — consumed by Build/Improve (future). The evaluator is JUDGE-ONLY (EV-051)
+ * RESERVED — consumed by Build/Optimize (future). The evaluator is JUDGE-ONLY (EV-051)
  * and never writes a target; `targets[].code_refs` is ported for shape parity only and
- * has NO evaluator consumer today. PURPOSE (future): tells BUILD/IMPROVE which files
+ * has NO evaluator consumer today. PURPOSE (future): tells BUILD/OPTIMIZE which files
  * realize the agent so a fix lands on the right def.
  */
 export const CodeRefSchema = Type.Object(
@@ -253,7 +253,7 @@ export type CodeRef = Static<typeof CodeRefSchema>;
  * HOW a fix is applied for a target. `kind` gates the report-only branch.
  * CONSUMER: the diagnostics APPLY path (not the evaluator — judge-only). PURPOSE:
  * selects the write mechanism for a fix.
- *   versioning / pr — RESERVED, consumed by Build/Improve (future). No evaluator
+ *   versioning / pr — RESERVED, consumed by Build/Optimize (future). No evaluator
  *                     consumer; ported for parity. PURPOSE (future): toggle spec-bump /
  *                     open-a-PR on apply.
  */

package/.claude/skills/mutagent-evaluator/scripts/contracts/eval-matrix.ts

@@ -184,6 +184,41 @@ export type SubjectProfileProvenanceValue =
  *  harness/skill marked UNKNOWN, never confabulated). */
 export const PROFILE_UNKNOWN = "unknown" as const;
 
+// ── EV-5 — tool reversibility (does a tool take an IRREVERSIBLE EXTERNAL action?) ─
+//
+// A routing failure that only READS is materially less severe than one that also
+// sends an email or mutates a live system — but nothing surfaced "this session could
+// take irreversible external actions." This classifies each subject tool so the judge
+// preamble can flag it. HONEST: `unknown` when the tool's effect can't be established
+// (never confabulated), never coerced to a false "reversible".
+export const ToolReversibility = {
+  /** a pure/no-op tool (no external effect). */
+  None: "none",
+  /** an external action that can be undone / re-run safely (a read, an idempotent write). */
+  Reversible: "reversible",
+  /** an external action that CANNOT be undone (send/email/charge/delete/deploy/post). */
+  IrreversibleExternal: "irreversible-external",
+  /** the tool's effect can't be established from the inputs — flagged, never guessed. */
+  Unknown: "unknown",
+} as const;
+export type ToolReversibilityValue =
+  (typeof ToolReversibility)[keyof typeof ToolReversibility];
+
+/** One tool's reversibility classification (EV-5). */
+export const ToolReversibilitySchema = Type.Object(
+  {
+    name: Type.String({ minLength: 1 }),
+    reversibility: Type.Union([
+      Type.Literal(ToolReversibility.None),
+      Type.Literal(ToolReversibility.Reversible),
+      Type.Literal(ToolReversibility.IrreversibleExternal),
+      Type.Literal(ToolReversibility.Unknown),
+    ]),
+  },
+  { additionalProperties: false },
+);
+export type ToolReversibilityEntry = Static<typeof ToolReversibilitySchema>;
+
 export const SubjectProfileSchema = Type.Object(
   {
     /** what the agent IS (name / role identity). */
@@ -195,6 +230,10 @@ export const SubjectProfileSchema = Type.Object(
     purpose: Type.String({ minLength: 1 }),
     /** the tools the agent wields (GIVEN inventory or reconstructed from the trace batch). */
     tools: Type.Array(Type.String({ minLength: 1 })),
+    /** EV-5 — per-tool reversibility (none · reversible · irreversible-external · unknown)
+     *  so the judge sees which tools take IRREVERSIBLE EXTERNAL actions BEFORE it weighs a
+     *  failure. ADDITIVE/OPTIONAL: absent ⇒ the judge reads the bare tool list. */
+    toolReversibility: Type.Optional(Type.Array(ToolReversibilitySchema)),
     /** the skill the agent runs under, when known (`unknown` ≠ confabulated). */
     skill: Type.Optional(Type.String()),
     /** the agent's responsibility boundary / scope. */

package/.claude/skills/mutagent-evaluator/scripts/determine-outcome.ts

@@ -39,6 +39,14 @@ import {
 export type JudgeInvoke = (
   systemPrompt: string,
   userPrompt: string,
+  /**
+   * INF-3 — an OPTIONAL session/trace id the DETERMINER passes so its verdict is
+   * keyed per-trace: two sessions with an identical (e.g. empty) determiner prompt
+   * never collapse onto one verdict file. Absent for the per-criterion judges (their
+   * prompts are already distinct; keying salt-free keeps their hashes byte-identical,
+   * C-PIN). Both agent-dispatch seams forward it to `verdictFileName(system,user,keyId)`.
+   */
+  keyId?: string,
 ) => Promise<string>;
 
 // ── Event classification (the intended-goal half of the read) ───────────────

package/.claude/skills/mutagent-evaluator/scripts/edd/change-request.ts

@@ -149,7 +149,7 @@ export interface EddLoopDecision {
  *   1. FULL GREEN   — varianceStable AND accuracyMet ⇒ DONE (success).
  *   2. MAX SWINGS   — swing ≥ budget.maxSwings ⇒ STOP (report delta).
  *   3. MAX WALLCLOCK— elapsedMs ≥ budget.maxWallclockMs ⇒ STOP.
- *   4. NO-IMPROVE   — noImprovementStreak ≥ budget.noImprovementStreakLimit ⇒ STOP.
+ *   4. NO-OPTIMIZE   — noImprovementStreak ≥ budget.noImprovementStreakLimit ⇒ STOP.
  *   else CONTINUE — keep swinging; the next phase is variance until it's stable,
  *   then accuracy (F19 ordering is preserved by `nextPhaseAfterVariance`, but the
  *   loop controller mirrors it: not-stable ⇒ variance, stable ⇒ accuracy).

package/.claude/skills/mutagent-evaluator/scripts/edd/edd-types.ts

@@ -1,10 +1,10 @@
 /**
  * scripts/edd/edd-types.ts
  * ---------------------------------------------------------------------------
- * Shared categorical constants + TypeBox contracts for the ADL IMPROVE stage —
+ * Shared categorical constants + TypeBox contracts for the ADL OPTIMIZE stage —
  * the Eval-Driven-Development (EDD) loop (F18 closure + F19 variance-first).
  *
- * EDD is the ③ IMPROVE stage of the ADL: after the initial *build, the loop
+ * EDD is the ③ OPTIMIZE stage of the ADL: after the initial *build, the loop
  * drives spec ↔ impl ↔ eval to full green. Two findings live here:
  *
  *   F19 — VARIANCE-FIRST. The FIRST focus after the build is eliminating per-case

package/.claude/skills/mutagent-evaluator/scripts/judge-prompt-template.ts

@@ -48,20 +48,94 @@ function promptOf(trace: EvalTrace): string {
 
 // ── Determiner (EV-042) prompt — MIRRORS assets/agents/error-analyst.md ──────
 
+/**
+ * EV-1 — the compact SUBJECT FRAME the determiner reads so it derives THIS subject's
+ * expected outcome (identity · purpose · tools + reversibility), instead of judging
+ * against a hardcoded email-agent signal block. Trajectory-LIGHT by design — it never
+ * carries the full step-by-step trajectory (that is the per-criterion judge's job).
+ */
+export interface SubjectFrame {
+  identity: string;
+  purpose: string;
+  tools: string[];
+  toolReversibility?: { name: string; reversibility: string }[];
+}
+
+/** The distinct tool names actually invoked in a trace, in first-seen order (compact summary). */
+function keyToolsUsed(trace: EvalTrace, limit = 8): string[] {
+  const seen: string[] = [];
+  for (const o of trace.observations) {
+    if (o.type === "TOOL" && typeof o.name === "string" && !seen.includes(o.name)) {
+      seen.push(o.name);
+      if (seen.length >= limit) break;
+    }
+  }
+  return seen;
+}
+
+/** Render the subject frame block for the determiner (EV-1). Trajectory-light. */
+function subjectFrameBlock(subject: SubjectFrame | undefined): string[] {
+  if (subject === undefined) {
+    return [
+      "SUBJECT: not supplied — RECONSTRUCT what the agent is from the input event + the",
+      "tools it called, and derive the expected outcome from that. Do NOT assume any",
+      "particular domain (e.g. email).",
+      "",
+    ];
+  }
+  const rev = new Map((subject.toolReversibility ?? []).map((t) => [t.name, t.reversibility]));
+  const toolLine =
+    subject.tools.length > 0
+      ? subject.tools
+          .map((n) => {
+            const r = rev.get(n);
+            return r !== undefined && r !== "unknown" ? `${n} [${r}]` : n;
+          })
+          .join(", ")
+      : "(none)";
+  const irreversible = (subject.toolReversibility ?? [])
+    .filter((t) => t.reversibility === "irreversible-external")
+    .map((t) => t.name);
+  return [
+    "SUBJECT (derive the EXPECTED outcome for THIS subject before you judge):",
+    `  identity: ${subject.identity}`,
+    `  purpose:  ${subject.purpose}`,
+    `  tools:    ${toolLine}`,
+    ...(irreversible.length > 0
+      ? [`  ⚠ irreversible-external tools: ${irreversible.join(", ")} — a failure that also fired one is materially worse.`]
+      : []),
+    "",
+  ];
+}
+
 /**
  * Render the determiner judge prompt for the in-house/export substrate. The
  * AUTHORITATIVE "inaction can be success" rubric is `error-analyst.md`; this is
  * its provider-callable mirror. No decision is made here.
+ *
+ * EV-1 — subject-aware: given a `subject` frame the determiner derives the expected
+ * outcome from the subject's identity/purpose/tools (not a fixed email-agent signal
+ * block), and reads a COMPACT outcome summary (event · did-it-act · key tools ·
+ * terminal state) — deliberately NOT the full trajectory (the per-criterion judge's
+ * job). The domain-specific signals (send / guard / recovery) render ONLY when the
+ * subject vocab actually defines them, so a non-email subject no longer sees dead lines.
  */
 export function buildOutcomePrompt(
   trace: EvalTrace,
   signals: OutcomeSignals,
   vocab: SubjectVocab,
+  subject?: SubjectFrame,
 ): { system: string; user: string } {
   const system = [
     "You are a success/failure determiner for an autonomous agent session.",
     "Decide whether the session REACHED THE GOAL implied by its input event.",
     "",
+    "Derive the EXPECTED outcome from the SUBJECT (its identity · purpose · tools) +",
+    "the input event — do NOT assume any particular domain (e.g. email). This is a",
+    "FAST input→output outcome check: read the goal (input), the result (output/self-",
+    "summary) and the compact summary below — NOT the full step-by-step trajectory",
+    "(that is the per-criterion judge's job).",
+    "",
     "CRITICAL RULE — inaction can be success. Holding (sending nothing, calling",
     "no tool) is the CORRECT outcome when the event is a restraint directive",
     "(e.g. a guard/hold directive) or when acting would be wrong. You MUST NOT",
@@ -74,23 +148,39 @@ export function buildOutcomePrompt(
     "Reason first in `critique`, then commit to `result`.",
   ].join("\n");
 
-  // Generic guard-counter label — the attribute NAME comes from the subject vocab.
-  const guardLabel = vocab.guardCounterAttr ?? "guard counter";
+  const responseText = typeof trace.output?.response === "string" ? trace.output.response : "";
+  const keyTools = keyToolsUsed(trace);
+
+  // EV-1 — domain signals render ONLY when the subject vocab defines them (else they
+  // were email-agent noise for every subject). honest-null preserved.
+  const conditionalSignals: string[] = [];
+  if (vocab.guardCounterAttr !== null) {
+    conditionalSignals.push(`  Guard ${vocab.guardCounterAttr}: ${signals.guardConsecutive ?? "n/a"}`);
+  }
+  if (vocab.sendTool.length > 0) {
+    conditionalSignals.push(
+      `  Sent a message: ${signals.sentMessage === null ? "unknown" : signals.sentMessage}`,
+      `  Send succeeded: ${signals.sendSucceeded ?? "n/a (no send)"}`,
+    );
+  }
+  if (vocab.recoveryTools.length > 0) {
+    conditionalSignals.push(`  Recovery tool present: ${signals.recoveryPresent}`);
+  }
+
   const user = [
-    `Event kind: ${signals.eventKind}`,
-    `Guard ${guardLabel}: ${signals.guardConsecutive ?? "n/a"}`,
-    `Tools called: ${signals.toolCount}`,
-    // EV-049 honest-null: render UNKNOWN as "unknown" (the subject's send tool is
-    // unset/uninferred) — never coerce it to "false", which would lie to the judge.
-    `Sent a message: ${signals.sentMessage === null ? "unknown" : signals.sentMessage}`,
-    `Send succeeded: ${signals.sendSucceeded ?? "n/a (no send)"}`,
-    `Recovery tool present: ${signals.recoveryPresent}`,
+    ...subjectFrameBlock(subject),
+    "OUTCOME SUMMARY (compact — NOT the full trajectory):",
+    `  Event kind: ${signals.eventKind}`,
+    `  Tools called: ${signals.toolCount}${keyTools.length > 0 ? ` · key tools: ${keyTools.join(", ")}` : ""}`,
+    `  Did the agent act: ${signals.toolCount > 0 ? "yes (called tools)" : "no (no tool calls)"}`,
+    `  Terminal state: ${responseText.length > 0 ? "produced a self-summary/response" : "no self-summary"}`,
+    ...conditionalSignals,
     "",
     "Input event prompt:",
     promptOf(trace),
     "",
     "Agent self-summary (output.response):",
-    typeof trace.output?.response === "string" ? trace.output.response : "(none)",
+    responseText.length > 0 ? responseText : "(none)",
   ].join("\n");
 
   return { system, user };
@@ -107,10 +197,13 @@ export async function determineOutcome(
   trace: EvalTrace,
   judge: JudgeInvoke,
   vocab: SubjectVocab,
+  subject?: SubjectFrame,
 ): Promise<OutcomeResult> {
   const signals = extractOutcomeSignals(trace, vocab);
-  const { system, user } = buildOutcomePrompt(trace, signals, vocab);
-  const raw = await judge(system, user);
+  const { system, user } = buildOutcomePrompt(trace, signals, vocab, subject);
+  // INF-3 — pass the trace id so the determiner verdict is keyed PER-TRACE (two
+  // sessions with an identical determiner prompt never share one verdict).
+  const raw = await judge(system, user, trace.id);
   const verdict = parseCritiqueVerdict(raw);
   return {
     traceId: trace.id,
@@ -153,7 +246,8 @@ function profilePreamble(profile?: SubjectProfile): string[] {
     `  identity: ${profile.identity}`,
     `  purpose:  ${profile.purpose}`,
     `  scope:    ${profile.scope}`,
-    `  tools:    ${(profile.tools ?? []).join(", ") || "(none observed)"}`,
+    `  tools:    ${renderToolLine(profile)}`,
+    ...reversibilityCallout(profile),
     profile.skill !== undefined ? `  skill:    ${profile.skill}` : "",
     `  harness:  ${profile.harness}`,
     `  provenance: ${profile.provenance}${profile.version !== undefined ? ` · version ${profile.version}` : ""}`,
@@ -161,6 +255,36 @@ function profilePreamble(profile?: SubjectProfile): string[] {
   ].filter((l) => l !== "");
 }
 
+/** Render the tools line, annotating each tool with its EV-5 reversibility when known. */
+function renderToolLine(profile: SubjectProfile): string {
+  const tools = profile.tools ?? [];
+  if (tools.length === 0) return "(none observed)";
+  const rev = new Map((profile.toolReversibility ?? []).map((t) => [t.name, t.reversibility]));
+  return tools
+    .map((name) => {
+      const r = rev.get(name);
+      return r !== undefined && r !== "unknown" ? `${name} [${r}]` : name;
+    })
+    .join(", ");
+}
+
+/**
+ * EV-5 — a one-line callout naming the tools that take IRREVERSIBLE EXTERNAL actions,
+ * so a failure that ALSO fired one weighs heavier than a read-only failure. Absent
+ * reversibility data ⇒ no callout (the judge still reads the bare tool list).
+ */
+function reversibilityCallout(profile: SubjectProfile): string[] {
+  const irreversible = (profile.toolReversibility ?? [])
+    .filter((t) => t.reversibility === "irreversible-external")
+    .map((t) => t.name);
+  if (irreversible.length === 0) return [];
+  return [
+    `  ⚠ irreversible-external tools: ${irreversible.join(", ")} — a failure that ALSO`,
+    "    fired one of these (an email sent, a live system mutated) is MATERIALLY WORSE",
+    "    than a read-only failure; weigh that in your critique.",
+  ];
+}
+
 /**
  * Render the 4-component per-criterion judge prompt for the in-house/export
  * substrate. The AUTHORITATIVE 4-component / binary / critique-before-verdict
@@ -227,6 +351,11 @@ export async function runJudge(
   subjectTrace: EvalTrace,
   judge: JudgeInvoke,
   pin: JudgePin,
+  // EV-5 CUT WIRE 1 — the M1 subject profile the judge reads in its preamble (tools +
+  // reversibility). Pre-fix runJudge called buildJudgePrompt WITHOUT it, so the export
+  // path always hit the "profile not supplied — reconstruct" branch and never saw the
+  // reversibility flags. The pipeline now builds it once (buildSubjectProfile) and passes it.
+  subjectProfile?: SubjectProfile,
 ): Promise<CriterionVerdict> {
   if (typeof pin.modelId !== "string" || pin.modelId.length === 0) {
     throw new Error(
@@ -240,7 +369,7 @@ export async function runJudge(
         "MODEL INTENT IS SACRED: reruns must be byte-identical (C-PIN); refusing.",
     );
   }
-  const { system, user } = buildJudgePrompt(spec, subjectTrace);
+  const { system, user } = buildJudgePrompt(spec, subjectTrace, subjectProfile);
   const raw = await judge(system, user);
   const verdict = parseCritiqueVerdict(raw);
   return {

package/.claude/skills/mutagent-evaluator/scripts/memory/append.ts

@@ -37,7 +37,7 @@ export const Lifecycle = {
   Build: "build",
   Evaluate: "evaluate",
   Diagnose: "diagnose",
-  Improve: "improve",
+  Optimize: "optimize",
   General: "general",
 } as const;
 export type LifecycleValue = (typeof Lifecycle)[keyof typeof Lifecycle];