@mutagent/helix 0.1.0-alpha.14

package/mutagent-evaluator/.claude/skills/mutagent-evaluator/scripts/substrate.ts

@@ -0,0 +1,162 @@
+/**
+ * scripts/substrate.ts — EV-050 judge-runtime selection.
+ * ---------------------------------------------------------------------------
+ * NOTE (v0.2.0 rename): `substrate` → `judge_runtime` in config + the public API
+ * (`resolveSubstrate`→`resolveJudgeRuntime`, `judgeForSubstrate`→`judgeForRuntime`).
+ * The enum VALUES are UNCHANGED (`agent-dispatch`/`in-house`/`code-based`/
+ * `user-framework`) and the EV-050 `Substrate` enum symbol (contracts/eval-types.ts)
+ * is kept — only the config KEY + the two selector functions were renamed.
+ *
+ * The W1 DEFAULT judge-runtime is **agent-dispatch** (scripts/agent-dispatch.ts):
+ * verdicts are produced by parent-session-dispatched eval-judge / error-analyst
+ * leaf subagents reasoning on the HOST runtime (Claude Code, diagnostics-style
+ * mass-dispatch) and read back from verdict FILES — the default path calls NO
+ * provider SDK. The onboarding choice (PRD §7.9) stays a real fork; this picks
+ * the DEFAULT the spine + dogfood build against, and STRUCTURES the rest as
+ * seams rather than hardcoding any single transport:
+ *
+ *   - agent-dispatch (DEFAULT) → a verdict-file-backed JudgeInvoke; the LLM
+ *                      reasoning happens in dispatched subagents on the host,
+ *                      NOT in a script. Requires `verdictDir` (where the
+ *                      dispatched subagents wrote their verdict files).
+ *   - in-house       (OPTIONAL) → a live LLM JudgeInvoke (google-genai shape);
+ *                      kept, not deleted — DEMOTED from default. For the CI /
+ *                      code-based export path that wants a provider call.
+ *   - code-based     → objective checks over tool outputs; runs WITHOUT an LLM
+ *                      judge → judgeForRuntime THROWS (deterministic code).
+ *   - user-framework → an EXPORT target (Vitest/promptfoo/Braintrust/…); the
+ *                      evaluator emits to it at onboarding → not a live judge.
+ *
+ * Why agent-dispatch is the default (operator correction 2026-06-19): the
+ * Evaluator's functions must be performed BY an Evaluator agent on Claude Code
+ * itself, mass-dispatched for throughput (mirror diagnostics), NOT by a script
+ * calling Gemini. In-house Gemini remains a real onboarding option (EV-050) but
+ * is no longer the spine default. Model intent stays sacred either way — the
+ * host's pinned model for agent-dispatch, the asserted provider model in-house.
+ */
+import { Substrate, type SubstrateValue } from "./contracts/eval-types.ts";
+import { createInHouseJudge } from "./judge-provider.ts";
+import { createAgentDispatchJudge } from "./agent-dispatch.ts";
+import type { JudgeInvoke } from "./determine-outcome.ts";
+
+const KNOWN_SUBSTRATES: ReadonlySet<string> = new Set([
+  Substrate.AgentDispatch,
+  Substrate.InHouse,
+  Substrate.UserFramework,
+  Substrate.CodeBased,
+]);
+
+/** Resolve the judge-runtime choice; default = agent-dispatch. Unknown → THROW (no silent default). */
+export function resolveJudgeRuntime(choice?: string): SubstrateValue {
+  if (choice === undefined || choice === "") return Substrate.AgentDispatch;
+  if (!KNOWN_SUBSTRATES.has(choice)) {
+    throw new Error(
+      `resolveJudgeRuntime: unknown judge_runtime '${choice}'. Choose one of ` +
+        `{${[...KNOWN_SUBSTRATES].join(", ")}}.`,
+    );
+  }
+  return choice as SubstrateValue;
+}
+
+export interface SubstrateDescription {
+  kind: SubstrateValue;
+  /** true for transports that yield a live JudgeInvoke (agent-dispatch · in-house);
+   *  false for the seams (code-based · user-framework). */
+  liveJudge: boolean;
+  /** the verdict transport: where the judge text comes from. */
+  transport: "agent-dispatch" | "provider-sdk" | "code" | "export";
+  /** true ONLY for the in-house provider-SDK path (the others never call a provider). */
+  callsProvider: boolean;
+  note: string;
+}
+
+/** Describe a substrate (which one provides a live judge, and via what transport). */
+export function describeSubstrate(s: SubstrateValue): SubstrateDescription {
+  switch (s) {
+    case Substrate.AgentDispatch:
+      return {
+        kind: s,
+        liveJudge: true,
+        transport: "agent-dispatch",
+        callsProvider: false,
+        note: "Claude Code agent-dispatch (DEFAULT) — verdicts from host-runtime subagents (verdict files), no provider",
+      };
+    case Substrate.InHouse:
+      return {
+        kind: s,
+        liveJudge: true,
+        transport: "provider-sdk",
+        callsProvider: true,
+        note: "in-house AI-SDK judge (OPTIONAL — demoted from default; provider-SDK call)",
+      };
+    case Substrate.CodeBased:
+      return {
+        kind: s,
+        liveJudge: false,
+        transport: "code",
+        callsProvider: false,
+        note: "objective code-checks over tool outputs — no LLM judge",
+      };
+    case Substrate.UserFramework:
+    default:
+      return {
+        kind: s,
+        liveJudge: false,
+        transport: "export",
+        callsProvider: false,
+        note: "export target (user's eval framework) — emit, not a live judge",
+      };
+  }
+}
+
+export interface SubstrateJudgeConfig {
+  substrate: SubstrateValue;
+  /** agent-dispatch: the dir the dispatched subagents wrote their verdict files into. */
+  verdictDir?: string;
+  /** in-house: the resolved (pinned) provider model. */
+  model?: string;
+  apiKey?: string;
+}
+
+/**
+ * Return a live `JudgeInvoke` for the judge-runtime.
+ *   - agent-dispatch (DEFAULT) → a verdict-file-backed judge (requires verdictDir);
+ *     NO provider is loaded.
+ *   - in-house (OPTIONAL) → the google-genai judge (requires a resolved model —
+ *     model intent sacred; createInHouseJudge asserts it).
+ *   - code-based / user-framework → SEAMS; THROW (no live judge to return).
+ */
+export function judgeForRuntime(cfg: SubstrateJudgeConfig): JudgeInvoke {
+  if (cfg.substrate === Substrate.AgentDispatch) {
+    if (cfg.verdictDir === undefined || cfg.verdictDir === "") {
+      throw new Error(
+        "judgeForRuntime(agent-dispatch): a verdictDir is required — it is the " +
+          "directory the parent session's dispatched eval-judge / error-analyst " +
+          "subagents wrote their verdict files into. PREP → dispatch → collect, " +
+          "then aggregate (references/workflows/orchestrator-protocol.md).",
+      );
+    }
+    return createAgentDispatchJudge({ verdictDir: cfg.verdictDir });
+  }
+  if (cfg.substrate === Substrate.InHouse) {
+    if (cfg.model === undefined || cfg.model === "") {
+      throw new Error(
+        "judgeForRuntime(in-house): a model is required (model intent sacred). " +
+          "Resolve it via resolveJudgeModel() and pass it through.",
+      );
+    }
+    return createInHouseJudge({ model: cfg.model, ...(cfg.apiKey !== undefined ? { apiKey: cfg.apiKey } : {}) });
+  }
+  if (cfg.substrate === Substrate.CodeBased) {
+    throw new Error(
+      "judgeForRuntime(code-based): code-based evals run WITHOUT an LLM judge — " +
+        "there is no live judge to return. Run the deterministic code-checks " +
+        "instead (this is a seam, not a live-judge path).",
+    );
+  }
+  throw new Error(
+    "judgeForRuntime(user-framework): the user's framework is an EXPORT seam, " +
+      "not a live judge. Emit the suite to the framework at onboarding; do not " +
+      "expect a JudgeInvoke here.",
+  );
+}

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

@@ -0,0 +1,244 @@
+/**
+ * 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,
+ * 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:
+ *
+ *   1. WHICH eval leg applies — the subject-kind resolver. The eval leg's shape differs
+ *      by subject kind (this is why W2I5 was gated behind W2I1's code-quality leg):
+ *        - agent / skill / composite subject → the EVAL-SUITE criteria (the evaluator's
+ *          discovered / maintained criteria for that subject).
+ *        - code subject → the CODE-QUALITY criteria (W2I1's `DEFAULT_CODE_QUALITY_CRITERIA`
+ *          / `#mode-judge-code-quality`).
+ *   2. A deterministic STALENESS FLAG predicate — the eval-leg half of the drift trigger
+ *      (mirrors the builder freshness probe's spec/code compare; same 3-value semantics).
+ *   3. The monotonic APPLY primitive — the ai-architect reasons a criteria delta; this
+ *      applies it as criteria MAINTENANCE: upsert-by-id, append the novel, and NEVER drop
+ *      an existing criterion (EV-053, guarded by `assertMonotonicGrowth`).
+ *
+ * JUDGE-ONLY PRESERVED (EV-051): this file NEVER scores a subject and NEVER decides a
+ * subject pass/fail. It FLAGS freshness (pure epoch compare) and GROWS a criteria set
+ * (pure set algebra). The reconcile REASONING — which criteria a changed impl makes stale,
+ * what new criterion it needs — is the ai-architect's, not this code's (Model-B: code =
+ * drift predicates + deterministic maintenance only, never agent dispatch).
+ *
+ * PURE + deterministic (C-PIN): no clock / random / network; same inputs → byte-identical.
+ */
+import { type Static, Type } from "@sinclair/typebox";
+import { Value } from "@sinclair/typebox/value";
+
+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. */
+export const EvalSubjectKind = {
+  Agent: "agent",
+  Skill: "skill",
+  Composite: "composite",
+  Code: "code",
+} as const;
+export type EvalSubjectKindValue = (typeof EvalSubjectKind)[keyof typeof EvalSubjectKind];
+
+/** Which eval leg grounds a subject's evaluation — the W2I5 core rule. */
+export const EvalLegKind = {
+  /** agent / skill / composite → the evaluator's discovered/maintained eval-suite criteria. */
+  EvalSuite: "eval-suite",
+  /** code → W2I1's code-quality criteria (`DEFAULT_CODE_QUALITY_CRITERIA`). */
+  CodeQuality: "code-quality",
+} as const;
+export type EvalLegKindValue = (typeof EvalLegKind)[keyof typeof EvalLegKind];
+
+/**
+ * Resolve WHICH eval leg a subject kind reconciles against. Code subjects use the
+ * code-quality criteria (a deterministic-test-gate PLUS a quality judge); every other
+ * kind uses the discovered eval-suite criteria. This single mapping is the shape
+ * differentiator the whole triad turns on.
+ */
+export function evalLegForSubjectKind(kind: EvalSubjectKindValue): EvalLegKindValue {
+  return kind === EvalSubjectKind.Code ? EvalLegKind.CodeQuality : EvalLegKind.EvalSuite;
+}
+
+// ── the staleness flag predicate (eval-leg half of the drift trigger) ────────
+
+/** The eval-leg freshness verdict — mirrors the builder freshness probe's 3-value spec/code semantics. */
+export const EvalLegDrift = {
+  /** no eval-criteria artifact yet — the eval leg must be CONSTRUCTED (cold). */
+  MissingEval: "missing-eval",
+  /** the eval criteria are as fresh as the impl — no reconcile write needed. */
+  InSync: "in-sync",
+  /** the impl is newer than the eval criteria — the eval leg is flagged for RECONCILE. */
+  NeedsSync: "needs-sync",
+} as const;
+export type EvalLegDriftValue = (typeof EvalLegDrift)[keyof typeof EvalLegDrift];
+
+/** Effective freshness epochs (seconds) the flag predicate compares. `null` = unknown/absent. */
+export interface EvalLegFreshnessInput {
+  /** effective freshness epoch of the eval-criteria artifact; `null` = artifact absent. */
+  evalCriteriaEpoch: number | null;
+  /** effective freshness epoch of the implementation; `null` = unknown. */
+  implEpoch: number | null;
+}
+
+/**
+ * FLAG whether the eval leg is stale w.r.t. the impl. Deterministic — a pure epoch
+ * compare, identical in spirit to the builder `check-sync-spec` spec/code compare so the
+ * two legs agree on "impl is newer → reconcile". This is a FLAG only: it decides nothing
+ * about the subject and proposes no criteria — the reconcile reasoning is the agent's.
+ */
+export function flagEvalLegDrift(input: EvalLegFreshnessInput): EvalLegDriftValue {
+  if (input.evalCriteriaEpoch == null) return EvalLegDrift.MissingEval;
+  if (input.implEpoch != null && input.implEpoch > input.evalCriteriaEpoch) {
+    return EvalLegDrift.NeedsSync;
+  }
+  return EvalLegDrift.InSync;
+}
+
+/** The resolved eval leg for a subject: which criteria kind + the current staleness flag. */
+export interface EvalLegAssessment {
+  leg: EvalLegKindValue;
+  drift: EvalLegDriftValue;
+}
+
+/**
+ * Convenience: resolve the eval leg for a subject kind AND flag its staleness in one
+ * call — the exact pair the reconcile reads ("which leg, is it stale?").
+ */
+export function assessEvalLeg(
+  subjectKind: EvalSubjectKindValue,
+  freshness: EvalLegFreshnessInput,
+): EvalLegAssessment {
+  return { leg: evalLegForSubjectKind(subjectKind), drift: flagEvalLegDrift(freshness) };
+}
+
+// ── the criteria representation + the monotonic reconcile-apply ──────────────
+
+/**
+ * One eval criterion — subject-kind-agnostic (a stable `id` key + the binary `statement`,
+ * plus the `leg` it belongs to and an optional severity). Serves BOTH legs: a code-quality
+ * `Qn` criterion (`severity` ∈ critical|high|medium) and an eval-suite discovered criterion
+ * flow through the same shape. `additionalProperties: true` keeps a richer criterion (e.g.
+ * a code-quality `passDefinition`/`failDefinition`, an eval-suite `checkMethod`) forward-parsing.
+ */
+export const EvalCriterionSchema = Type.Object(
+  {
+    id: Type.String({ minLength: 1 }),
+    statement: Type.String({ minLength: 1 }),
+    leg: Type.Union([Type.Literal(EvalLegKind.EvalSuite), Type.Literal(EvalLegKind.CodeQuality)]),
+    severity: Type.Optional(Type.String({ minLength: 1 })),
+  },
+  { additionalProperties: true },
+);
+export type EvalCriterion = Static<typeof EvalCriterionSchema>;
+
+/**
+ * The reconcile REQUEST the ai-architect emits: the persisted criteria `existing`, plus the
+ * agent-reasoned `proposed` additions/updates. `proposed` is an UPSERT set (append the novel,
+ * revise a same-id criterion's wording for the changed impl) — it is NEVER a delete list; the
+ * monotonic-growth invariant (EV-053) forbids dropping a criterion.
+ */
+export const EvalCriteriaReconcileRequestSchema = Type.Object(
+  {
+    subjectId: Type.String({ minLength: 1 }),
+    subjectKind: Type.Union([
+      Type.Literal(EvalSubjectKind.Agent),
+      Type.Literal(EvalSubjectKind.Skill),
+      Type.Literal(EvalSubjectKind.Composite),
+      Type.Literal(EvalSubjectKind.Code),
+    ]),
+    leg: Type.Union([Type.Literal(EvalLegKind.EvalSuite), Type.Literal(EvalLegKind.CodeQuality)]),
+    existing: Type.Array(EvalCriterionSchema),
+    proposed: Type.Array(EvalCriterionSchema),
+  },
+  { additionalProperties: false },
+);
+export type EvalCriteriaReconcileRequest = Static<typeof EvalCriteriaReconcileRequestSchema>;
+
+/** Provenance for a reconcile — pure counters (NO clock, for byte-identity / C-PIN). */
+export interface EvalCriteriaReconcileProvenance {
+  /** how many genuinely-novel criteria were appended. */
+  added: number;
+  /** how many existing criteria (same id) had their content revised. */
+  updated: number;
+  /** total criteria after the reconcile. */
+  total: number;
+}
+
+/** The reconcile RESULT — the grown/maintained criteria set + provenance. */
+export interface EvalCriteriaReconcileResult {
+  subjectId: string;
+  leg: EvalLegKindValue;
+  criteria: EvalCriterion[];
+  provenance: EvalCriteriaReconcileProvenance;
+}
+
+/** Parse + narrow a reconcile request (guarded). THROWS on schema violation. PURE. */
+export function parseEvalCriteriaReconcileRequest(value: unknown): EvalCriteriaReconcileRequest {
+  if (!Value.Check(EvalCriteriaReconcileRequestSchema, value)) {
+    const first = [...Value.Errors(EvalCriteriaReconcileRequestSchema, value)][0];
+    throw new Error(
+      `parseEvalCriteriaReconcileRequest: schema violation at '${first?.path ?? "(root)"}': ` +
+        `${first?.message ?? "invalid eval-criteria reconcile request"}`,
+    );
+  }
+  return value;
+}
+
+const criterionId = (c: EvalCriterion): string => c.id;
+
+/**
+ * APPLY the reconcile: maintain the eval-criteria set for a changed impl. Criteria
+ * MAINTENANCE, not judging (EV-051): upsert each `proposed` criterion by `id` (revise a
+ * same-id criterion's content in place, keeping the id), append the genuinely-novel, and
+ * assert the id-set NEVER shrank (EV-053, via the shared `assertMonotonicGrowth`). The
+ * `leg` on every proposed criterion must match the request's `leg` — mixing a code-quality
+ * criterion into an eval-suite reconcile (or vice versa) is a hard error, not a silent
+ * accept. DETERMINISTIC + PURE: existing order preserved, novel appended in proposal order;
+ * no clock / random. Same (existing, proposed) → byte-identical result.
+ */
+export function reconcileEvalCriteria(
+  request: EvalCriteriaReconcileRequest,
+): EvalCriteriaReconcileResult {
+  const req = parseEvalCriteriaReconcileRequest(request);
+
+  for (const p of req.proposed) {
+    if (p.leg !== req.leg) {
+      throw new Error(
+        `reconcileEvalCriteria: proposed criterion '${p.id}' has leg '${p.leg}' but the ` +
+          `reconcile targets leg '${req.leg}'. An eval-suite and a code-quality criterion ` +
+          "are different legs — refusing to mix them (subject-kind integrity).",
+      );
+    }
+  }
+
+  // Insertion-ordered upsert: existing order first (content possibly revised), novel appended.
+  const byId = new Map<string, EvalCriterion>();
+  for (const c of req.existing) byId.set(c.id, c);
+
+  let added = 0;
+  let updated = 0;
+  for (const p of req.proposed) {
+    if (byId.has(p.id)) {
+      byId.set(p.id, p); // revise content, id (and thus the key/order) retained
+      updated += 1;
+    } else {
+      byId.set(p.id, p); // novel → appended after the existing keys
+      added += 1;
+    }
+  }
+
+  const criteria = [...byId.values()];
+  // EV-053: a maintained criteria set may GROW or revise, but never DROP a criterion.
+  assertMonotonicGrowth(req.existing, criteria, criterionId);
+
+  return {
+    subjectId: req.subjectId,
+    leg: req.leg,
+    criteria,
+    provenance: { added, updated, total: criteria.length },
+  };
+}

package/mutagent-evaluator/.claude/skills/mutagent-evaluator/scripts/ui-slots.ts

@@ -0,0 +1,119 @@
+/**
+ * scripts/ui-slots.ts — EV-039/040 HTML-artifact missing-data audit (Code-only).
+ * ---------------------------------------------------------------------------
+ * The operator's first-class case: *"if a skill/agent produces an HTML artifact,
+ * data-leak is concerned with MISSING DATA in the UI representation."* A value
+ * the agent COMPUTED but did NOT render is a missing-data leak.
+ *
+ * This is the deterministic, SUBJECT-AGNOSTIC half of the EV-039/040 Hybrid: it
+ * cross-references a PROFILE-SUPPLIED expected-UI-slot list (EV-037
+ * `expectedUiSlots`, NOT the v1 diagnostics-specific hardcoded slot names) against
+ * the agent's computed values + the published HTML, and classifies each slot:
+ *   - computed-but-not-rendered (EV-039) — a value computed yet ABSENT from the
+ *     HTML → missing-data leak (locus UI, cls B). The operator's exact case;
+ *     works on the HTML-only path (the v1 OUTSIDER FALLBACK promoted to
+ *     first-class — no intermediate render-input file required).
+ *   - orphan slot (EV-039) — the HTML references the slot but NO producer
+ *     computed it → drawn-but-empty.
+ *   - faithful — computed AND rendered verbatim → explicitly NOT a leak.
+ * Nuanced faithfulness (altered/truncated, EV-040) is left to the judge — this
+ * helper flags only verbatim presence/absence (it decides no severity).
+ *
+ * PURE + deterministic: no clock / random / network; same inputs → same audit.
+ */
+
+/** Classification of one expected UI slot. */
+export const UiSlotKind = {
+  /** Computed by the agent but ABSENT from the rendered HTML (EV-039 leak). */
+  ComputedNotRendered: "computed-not-rendered",
+  /** Referenced in the HTML but NO producer computed it (EV-039 orphan). */
+  OrphanSlot: "orphan-slot",
+  /** Computed AND rendered verbatim — NOT a leak. */
+  Faithful: "faithful",
+  /** Neither computed nor referenced in the HTML — out of scope this run. */
+  Absent: "absent",
+} as const;
+export type UiSlotKindValue = (typeof UiSlotKind)[keyof typeof UiSlotKind];
+
+export interface UiSlotFinding {
+  slot: string;
+  kind: UiSlotKindValue;
+  /** the computed value string (when the agent produced one). */
+  computedValue?: string;
+  /** whether the slot is referenced (by name) anywhere in the HTML. */
+  slotReferenced: boolean;
+  /** whether the computed value appears verbatim in the HTML. */
+  valueRendered: boolean;
+}
+
+export interface UiSlotAuditInput {
+  /** EV-037 profile-supplied expected UI slots (subject-agnostic). */
+  expectedSlots: string[];
+  /** slot -> the value the agent COMPUTED (from trace / runMeta / intermediate). */
+  computedSlots: Record<string, string>;
+  /** the published HTML artifact text (the HTML-only path is supported). */
+  renderedHtml: string;
+}
+
+export interface UiSlotAudit {
+  findings: UiSlotFinding[];
+  /** EV-039 leaks: computed but not in the HTML. */
+  computedNotRendered: string[];
+  /** EV-039 orphans: referenced in the HTML but never computed. */
+  orphanSlots: string[];
+}
+
+/** Does the HTML reference this slot by name (a token match)? */
+function slotReferenced(html: string, slot: string): boolean {
+  if (slot.length === 0) return false;
+  return html.includes(slot);
+}
+
+/** Does the computed value appear verbatim in the HTML? */
+function valueRendered(html: string, value: string): boolean {
+  const v = value.trim();
+  if (v.length === 0) return false;
+  return html.includes(v);
+}
+
+/**
+ * Audit the expected UI slots against the computed values + the rendered HTML.
+ * PURE + deterministic. SUBJECT-AGNOSTIC — the slot list is supplied, never a
+ * module constant. Findings are emitted in `expectedSlots` order (stable).
+ */
+export function auditUiSlots(input: UiSlotAuditInput): UiSlotAudit {
+  const findings: UiSlotFinding[] = [];
+  const computedNotRendered: string[] = [];
+  const orphanSlots: string[] = [];
+
+  for (const slot of input.expectedSlots) {
+    const hasComputed = Object.prototype.hasOwnProperty.call(input.computedSlots, slot);
+    const computedValue = hasComputed ? input.computedSlots[slot] : undefined;
+    const referenced = slotReferenced(input.renderedHtml, slot);
+    const rendered =
+      computedValue !== undefined && valueRendered(input.renderedHtml, computedValue);
+
+    let kind: UiSlotKindValue;
+    if (hasComputed && !rendered) {
+      kind = UiSlotKind.ComputedNotRendered; // EV-039: computed but missing from HTML
+      computedNotRendered.push(slot);
+    } else if (!hasComputed && referenced) {
+      kind = UiSlotKind.OrphanSlot; // EV-039: drawn but no producer
+      orphanSlots.push(slot);
+    } else if (hasComputed && rendered) {
+      kind = UiSlotKind.Faithful;
+    } else {
+      kind = UiSlotKind.Absent;
+    }
+
+    findings.push({
+      slot,
+      kind,
+      ...(computedValue !== undefined ? { computedValue } : {}),
+      slotReferenced: referenced,
+      valueRendered: rendered,
+    });
+  }
+
+  return { findings, computedNotRendered, orphanSlots };
+}