@mutagent/helix 0.1.0-alpha.14

package/mutagent-evaluator/.claude/skills/mutagent-evaluator/subjects/mutagent-diagnostics/methodology-review.yaml

@@ -0,0 +1,105 @@
+# subjects/mutagent-diagnostics/methodology-review.yaml
+# ============================================================================
+# The MR-1..9 rubric for the diagnostics subject (Tab-4 — fitness, not
+# conformance). Conforms to schemas/methodology-review.schema.yaml. The
+# methodology-critic lens reads these items; all are advisory (never gate).
+#
+# MR-7/8/9 are the concrete instances of the generic engine: signal-selection,
+# confidence-derivation, focus-determination — the highest-leverage methodology
+# decisions for diagnostics. For ANY subject the evaluator judges sub-decisions
+# the same way (expected-decision vs observed-decision at each behavior-tree node).
+#
+# NDA: synthetic identifiers only. generatedAt is a fixed sentinel (masked).
+# ============================================================================
+subject: mutagent-diagnostics
+version: v1
+generatedAt: '1970-01-01T00:00:00.000Z'
+
+items:
+  - id: MR-1
+    title: Decision-tree fitness
+    reads: behavior-tree.yaml + run outcomes
+    how: >-
+      Judge reasons over each fork in the methodology (Step 3a scope-pick · 4.5
+      library/double-zero · 6 analyzer-count · copy-back) vs what the run
+      actually needed; flags dead / rarely-useful / mis-placed forks.
+    family: decision-tree-fitness
+    advisory: true
+
+  - id: MR-2
+    title: Data-flow efficiency
+    reads: normalize -> tier0 -> slice -> sample -> enrich -> render trace
+    how: >-
+      Scans the data pipeline for duplicated/recomputed transforms, stages that
+      could collapse or parallelize, artifacts produced-and-never-consumed.
+    family: data-flow-efficiency
+    advisory: true
+
+  - id: MR-3
+    title: Methodology fitness GIVEN the findings
+    reads: run trajectory + findings
+    how: >-
+      Was the deep-read tier / analyzer count / sampling over- or under-scaled
+      for what the findings turned out to be? Over-investigation = cost; under =
+      missed signal.
+    family: methodology-fitness
+    advisory: true
+
+  - id: MR-4
+    title: Sequence soundness
+    reads: transcript trajectory
+    how: >-
+      Reactive one-at-a-time crash patching, re-dispatch loops, redo-after-
+      failure = methodology smells that say the order/contract is wrong, not
+      just the code.
+    family: sequence-soundness
+    advisory: true
+
+  - id: MR-5
+    title: Process self-feedback
+    reads: all of the above
+    how: >-
+      Concrete, impact-ranked recommendations to restructure the methodology
+      itself (collapse a stage, drop a fork, re-order, pin a choice) — advisory.
+    family: process-self-feedback
+    advisory: true
+
+  - id: MR-6
+    title: Followed != Right
+    reads: matrix (Tab-1) vs this (Tab-4)
+    how: >-
+      A methodology can score 100% conformance (Tab-1) and still be the wrong/
+      inefficient choice; this family answers the second question independently.
+    family: conformance-vs-fitness
+    advisory: true
+
+  - id: MR-7
+    title: Signal / failure-mode SELECTION
+    reads: tier0 -> awareness -> deep-read -> reconcile chain
+    how: >-
+      Judge whether the primary signal was grounded in the RIGHT tier of
+      evidence (mechanical {loop·latency·cost} vs deep-read-evidenced failure-
+      WHAT) — not a frequency artifact or an unsupported pick. Highest-leverage
+      methodology decision: it steers everything downstream.
+    family: signal-selection
+    advisory: true
+
+  - id: MR-8
+    title: CONFIDENCE derivation
+    reads: coverageConfidence + primarySignal.confidence vs the deep-read sample
+    how: >-
+      Judge whether the confidence actually FOLLOWS from the LLM-trace evidence +
+      sample representativeness — catches 'high confidence on a 1/1/1/137
+      imbalanced sample': a number asserted, not earned.
+    family: confidence-derivation
+    advisory: true
+
+  - id: MR-9
+    title: FOCUS determination -> search-shaping
+    reads: scope/focus decision + which traces were then examined
+    how: >-
+      Because focus CHANGES the search, a wrong/early focus mis-steers every
+      downstream trace selection. Expected-focus vs observed-focus given the
+      brief + tier-0 signals.
+    family: focus-determination
+    advisory: true

package/mutagent-evaluator/.claude/skills/mutagent-evaluator/workflows/audit.workflow.js

@@ -0,0 +1,82 @@
+/**
+ * workflows/audit.workflow.js  →  the 4-tab master-audit harness (Mode A)
+ * ----------------------------------------------------------------------------
+ * The harness COMPOSES the workflows the evaluator already ships — it does not
+ * rebuild what exists. It:
+ *   1. runs the DETERMINISTIC spine (scripts/cli/audit-run.ts) to produce the
+ *      Tab-1 deterministic rows + the two-track scorecard + the base report;
+ *   2. dispatches the PINNED JUDGE over the Tab-1 judge rows (decision / data /
+ *      trajectory lenses) against the subject behavior-tree;
+ *   3. composes Tab-2 via data-leak.workflow.js (self-contained);
+ *   4. composes Tab-3 via variance.workflow.js (self-contained);
+ *   5. composes Tab-4 via the methodology-critic lens;
+ *   6. stamps the final 4-tab HTML from the EVALUATOR's own brand asset.
+ *
+ * GENERIC: every subject-specific input is supplied via args (subject · runId ·
+ * bundleDir). Defaults are SYNTHETIC. NO production dataset is named.
+ *
+ * JUDGE-EXECUTION SEAM: the `agent()` calls dispatch the pinned judge. The
+ * deterministic spine (step 1) is fully wired and runnable standalone via
+ * `audit-run.ts`; the judge tabs are the documented seams. Run via the workflow
+ * harness, NOT standalone node.
+ */
+export const meta = {
+  name: 'evaluator-audit',
+  description: 'Compose the 4-tab master-audit (eval-matrix · data-leak · variance · methodology) from a subject profile + run-bundle',
+  phases: [
+    { title: 'Deterministic spine', detail: 'audit-run.ts → Tab-1 deterministic rows + two-track scorecard' },
+    { title: 'Judge rows', detail: 'pinned judge over Tab-1 trace-cross-ref / trajectory-diff rows' },
+    { title: 'Compose tabs', detail: 'data-leak (Tab-2) · variance (Tab-3) · methodology (Tab-4)' },
+    { title: 'Render', detail: 'stamp the 4-tab HTML from the evaluator brand' },
+  ],
+}
+
+let A = args
+if (typeof A === 'string') { try { A = JSON.parse(A) } catch (e) { A = {} } }
+A = A || {}
+
+const SUBJECT = A.subject || 'sample-agent'
+const RUN_ID = A.runId || '<run-id>'
+const BUNDLE_DIR = A.bundleDir || '<run-bundle-dir>'
+const PKG = A.pkgRoot || '.'          // the evaluator package root
+const GEN = A.generatedAt || '1970-01-01T00:00:00.000Z'
+const STYLEREF = `${PKG}/assets/brand/theme.css`
+
+// ── Phase 1 — deterministic spine (fully wired script) ──────────────────────
+phase('Deterministic spine')
+const spine = await agent(
+  `Run the DETERMINISTIC spine for the master audit. Use Bash:\n` +
+  `  bash ${PKG}/scripts/cli/run.sh ${PKG}/scripts/cli/audit-run.ts ${RUN_ID} --subject ${SUBJECT} --bundle-dir ${BUNDLE_DIR} --subjects-root ${PKG}/subjects --generated-at ${GEN}\n` +
+  `This writes the master-audit under the unified evaluator reports root: .mutagent/evaluator/reports/<runId>/master-audit.html + master-audit.scorecard.json (two-track GATE+TREND). Return the parsed JSON the script prints (subject, runId, criteria, deterministicRows, judgeRows, gateRunPass, scorecard, report).`,
+  { label: 'spine:audit-run', phase: 'Deterministic spine' },
+)
+log(`spine: ${spine && spine.criteria} criteria, ${spine && spine.deterministicRows} deterministic + ${spine && spine.judgeRows} judge rows; gateRunPass=${spine && spine.gateRunPass}`)
+
+// ── Phase 2 — pinned judge over the Tab-1 judge rows ────────────────────────
+phase('Judge rows')
+const judge = await agent(
+  `PINNED JUDGE (model id + temperature=0, recorded; mask output). Read ${PKG}/subjects/${SUBJECT}/behavior-tree.yaml and the run-bundle at ${BUNDLE_DIR}. For each Tab-1 judge row (checkMethod trace-cross-ref or trajectory-diff in ${PKG}/subjects/${SUBJECT}/eval-matrix.yaml), apply the matching lens:\n` +
+  `  - decision rows → ${PKG}/lenses/decision-lens.md\n` +
+  `  - data rows     → ${PKG}/lenses/data-lens.md\n` +
+  `  - trajectory rows → ${PKG}/lenses/trajectory-lens.md\n` +
+  `Compare expected-decision vs observed-decision at each behavior-tree node. Emit one masked verdict per row (pass/fail + evidence + rationale). NEVER fabricate — an unobservable decision is a fail, not a pass.`,
+  { label: 'judge:tab1', phase: 'Judge rows' },
+)
+
+// ── Phase 3 — compose Tab-2, Tab-3, Tab-4 ──────────────────────────────────
+phase('Compose tabs')
+const tab2 = await workflow({ scriptPath: `${PKG}/workflows/data-leak.workflow.js`, args: { subjectRoot: A.subjectRoot, bundleDirs: [BUNDLE_DIR], outDir: `${BUNDLE_DIR}/audit`, styleRef: STYLEREF, generatedAt: GEN } })
+const tab3 = await workflow({ scriptPath: `${PKG}/workflows/variance.workflow.js`, args: { subjectPath: A.subjectRoot, label: RUN_ID, mode: A.varianceMode || 'full' } })
+const tab4 = await agent(
+  `Tab-4 methodology critic (ADVISORY, not pass/fail; pinned + masked). Run ${PKG}/lenses/methodology-critic-lens.md over: ${PKG}/subjects/${SUBJECT}/behavior-tree.yaml + ${PKG}/subjects/${SUBJECT}/methodology-review.yaml + the run trajectory at ${BUNDLE_DIR}. Emit ranked process self-feedback (MR-1..9). Write the Tab-4 HTML fragment to ${BUNDLE_DIR}/audit/tab4-methodology.html using the evaluator brand (${STYLEREF}). Return { written, mrFindings }.`,
+  { label: 'compose:tab4', phase: 'Compose tabs' },
+)
+
+// ── Phase 4 — final render (inline the tab fragments into the base report) ──
+phase('Render')
+const render = await agent(
+  `Stamp the FINAL 4-tab master-audit HTML. Use Bash to read the base report at ${spine && spine.report}, inline the three composed fragments (${BUNDLE_DIR}/audit/tab2-data-leak.html, the Tab-3 fragment from the variance workflow, ${BUNDLE_DIR}/audit/tab4-methodology.html) into panels t2/t3/t4, and overwrite ${spine && spine.report}. The brand (dark theme + MUTAGENT wordmark) comes from ${PKG}/assets/brand/theme.css — already embedded by the base renderer. Verify: 4 tab buttons, every panel non-empty, NO client identity in the output. Return { report, tabs: 4, ok }.`,
+  { label: 'render:final', phase: 'Render' },
+)
+
+return { subject: SUBJECT, runId: RUN_ID, spine, judge, tab2, tab3, tab4, render }

package/mutagent-evaluator/.claude/skills/mutagent-evaluator/workflows/data-leak.workflow.js

@@ -0,0 +1,236 @@
+/**
+ * workflows/data-leak.workflow.js  →  Tab-2 (Data-Leak)
+ * ----------------------------------------------------------------------------
+ * SELF-CONTAINED port of the mdiag-master-audit workflow (taken IN, not
+ * referenced). Audits a run-bundle for OPERATIONAL / CONTRACT-BOUNDARY +
+ * UI/render + DATA-CORRECTNESS leaks — data a component produces that the next
+ * component's contract drops, OR a renderer slot with no producer.
+ *
+ * GENERIC + subject-agnostic: every subject-specific path is supplied via args
+ * (subjectRoot · bundleDirs · styleRef). Defaults are SYNTHETIC (sample-agent /
+ * sample-email-agent / sample-tenant) — NO production dataset is named (design
+ * decision #10). The original client identities (and any /Users home paths) have
+ * been scrubbed.
+ *
+ * JUDGE-EXECUTION SEAM: the `agent(...)` / `parallel(...)` / `phase(...)` calls
+ * are the workflow-harness DSL (Workflow({scriptPath})). They dispatch the
+ * pinned judge. This file is the deterministic harness around those seams; the
+ * judge does the reading. Run via the workflow harness, NOT standalone node.
+ */
+export const meta = {
+  name: 'evaluator-data-leak',
+  description:
+    'Self-contained data-leak audit of a run-bundle + agent context-flow (operational/contract-boundary · UI/render · data-correctness+signal-selection · context-flow EV-028/029) → Tab-2 graph',
+  phases: [
+    { title: 'Audit dimensions', detail: 'parallel: operational/contract-boundary · UI/render · data-correctness+signal-selection · context-flow (EV-028/029)' },
+    { title: 'Synthesize', detail: 'merge leaks → master list + Tab-2 HTML fragment' },
+  ],
+}
+
+// ── Params: synthetic defaults, overridable via args ──────────────────────────
+let A = args
+if (typeof A === 'string') { try { A = JSON.parse(A) } catch (e) { A = {} } }
+A = A || {}
+
+// SUBJECT root + the run-bundle(s) under audit — supplied by the harness. The
+// defaults are SYNTHETIC placeholders, never a real client path.
+const SUBJECT = A.subjectRoot || '<subject-skill-root>'
+const REPORTS = A.bundleDirs || ['<run-bundle-dir>']
+const OUT = A.outDir || '<audit-out-dir>'
+const STYLEREF = A.styleRef || '<brand-style-ref>'   // evaluator's own assets/brand/theme.css
+const GEN = A.generatedAt || '1970-01-01T00:00:00Z'  // injected; masked for byte-identity
+
+// ── Agent context-flow inputs (EV-028/029) — SUBJECT-AGNOSTIC, supplied ──────
+// The deterministic flow-graph(s) (EV-032) + expected-flow (EV-037) the
+// context-flow dimension reasons over. `contextFlowCandidates` is the
+// deterministic PREP bundle (scripts/flow-graph.ts: unthreaded outputs = EV-028
+// candidates · lossy handoffs = EV-029 candidates) the judge ADJUDICATES. All
+// names come from these structures — NEVER a subject constant in the prompt.
+const FLOWGRAPHS = A.flowGraphs || []                 // EV-032 graphs for the audited traces
+const EXPECTEDFLOW = A.expectedFlow || { dispatchToolNames: [], edges: [], expectedUiSlots: [] }
+const CFCANDIDATES = A.contextFlowCandidates || []    // per-trace contextFlowCandidates output
+const CFLENS = A.contextFlowLens || '<context-flow-lens-ref>'  // lenses/context-flow-lens.md
+// Profile-supplied expected-UI-slot list (EV-039/040) — de-hardcodes the
+// diagnostics-specific renderer slots into a subject-agnostic list.
+const UISLOTS = (EXPECTEDFLOW.expectedUiSlots && EXPECTEDFLOW.expectedUiSlots.length)
+  ? EXPECTEDFLOW.expectedUiSlots
+  : (A.expectedUiSlots || [])
+// Deterministic EV-039 audit (scripts/ui-slots.ts auditUiSlots) per bundle:
+// { computedNotRendered, orphanSlots, findings } — the HTML-artifact missing-data
+// case made first-class. The judge ADJUDICATES these + the EV-040 faithfulness.
+const UISLOTAUDIT = A.uiSlotAudit || []
+
+const LEAK_SCHEMA = {
+  type: 'object',
+  additionalProperties: false,
+  properties: {
+    dimension: { type: 'string' },
+    summary: { type: 'string' },
+    leaks: {
+      type: 'array',
+      items: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+          id: { type: 'string', description: 'short id e.g. OP-1 / UI-2 / DC-3' },
+          title: { type: 'string' },
+          locus: { type: 'string', enum: ['C2C', 'UI'], description: 'C2C=lost between components; UI=produced but not drawn' },
+          cls: { type: 'string', enum: ['A', 'B'], description: 'A=contract too narrow; B=producer not run/threaded' },
+          producer: { type: 'string', description: 'the component/script that should emit it' },
+          whyNotProduced: { type: 'string' },
+          formalStructure: { type: 'string', enum: ['none', 'partial', 'exists'], description: 'is a schema/contract defined for this handoff?' },
+          severity: { type: 'string', enum: ['HIGH', 'MED', 'LOW'] },
+          whatsLost: { type: 'string' },
+          evidence: { type: 'string', description: 'file:line or command output proving it' },
+        },
+        required: ['id', 'title', 'locus', 'cls', 'producer', 'whyNotProduced', 'formalStructure', 'severity', 'whatsLost', 'evidence'],
+      },
+    },
+  },
+  required: ['dimension', 'summary', 'leaks'],
+}
+
+phase('Audit dimensions')
+
+const REPLIST = REPORTS.join(' , ')
+
+// The three audit dimensions. Prompts are GENERIC: they reference the SUBJECT
+// root + the run-bundle(s) supplied in args, and name only the canonical
+// pipeline stages (normalize → tier0 → slice → sample → enrich → render) and the
+// well-known artifact shapes — never a client-specific path or dataset.
+const DIMS = [
+  {
+    key: 'operational',
+    prompt: `You are auditing the SUBJECT skill (root: ${SUBJECT}) for OPERATIONAL / CONTRACT-BOUNDARY data leaks — data a component produces that the next component's contract drops, OR a renderer slot with no producer. READ-ONLY (grep/read; never edit).
+
+Run these concrete checks and emit ONE leak per real finding (ground each in an actual grep/read — no speculation). SUBJECT-AGNOSTIC: where a check names slots, use the PROFILE-SUPPLIED expected-UI-slot list below, NOT any hardcoded name. Checks 2-6 apply when the SUBJECT is a data-pipeline (skip the ones that don't map to this subject's shape).
+
+EXPECTED-UI-SLOTS (EV-037, profile-supplied):
+${JSON.stringify(UISLOTS, null, 2)}
+
+1. For EACH expected-UI-slot the renderer dereferences, grep the orchestrator protocol + scripts for a step that PRODUCES/threads it. If none → leak (cls B, locus UI, formalStructure exists).
+2. Read the Finding/Remedy/Assumption interfaces — are required fields (rationale/whyWorks/applyTarget/applyInstructions/assumptions) OPTIONAL? If yes → leak (cls A, formalStructure partial).
+3. Is there a findings-contract / required-field validator? If absent → leak (cls B, formalStructure none — the enabler).
+4. grep the enricher for the fail-loud threshold ('missing.length >= N'). If N>=3 → single-section silent-drop leak (cite the line).
+5. grep the platform normalizer for an 'import.meta.main' CLI entrypoint. If absent → the extractor has no CLI transport → leak.
+6. Read the signal-census builder — does it rank candidate signals by frequency only (severity unused)? If yes → signal-selection leak.
+
+Return the LEAK_SCHEMA object with dimension="operational".`,
+  },
+  {
+    key: 'ui-render',
+    prompt: `You are auditing the GENERATED HTML artifact(s) in the run-bundle(s) for UI/render data-leaks — the operator's FIRST-CLASS "HTML-artifact missing-data" case: a value the agent COMPUTED that is ABSENT from the HTML it produced is a missing-data leak. Bundle dirs: ${REPLIST}. READ-ONLY. SUBJECT-AGNOSTIC — the slots to check come from the PROFILE-SUPPLIED expected-UI-slot list, NOT any hardcoded slot name.
+
+EXPECTED-UI-SLOTS (EV-037, profile-supplied — the slots the subject's HTML SHOULD render):
+${JSON.stringify(UISLOTS, null, 2)}
+
+DETERMINISTIC EV-039 AUDIT (scripts/ui-slots.ts auditUiSlots, per bundle — { computedNotRendered, orphanSlots, findings }). ADJUDICATE these (they are CANDIDATES; confirm + severity):
+${JSON.stringify(UISLOTAUDIT, null, 2)}
+
+Checks (ground EACH in a read of the artifact — emit one leak per real finding):
+1. computed-but-not-rendered (EV-039): for each slot in computedNotRendered (and any expected-UI-slot you can confirm was computed in the trace/runMeta/intermediate output yet does NOT appear in the HTML) → leak (locus UI, cls B, formalStructure=exists). This is the operator's exact case.
+2. orphan slot (EV-039): for each slot in orphanSlots (the HTML references the slot but NO producer computed it) → drawn-but-empty leak (locus UI).
+3. render defect: grep each report HTML for an inline-JS split-regex with a raw CR byte inside the literal — that SyntaxError kills the copy/clipboard export → leak (HIGH).
+HTML-ONLY PATH (first-class, no longer a mere fallback): if a <dir> has the published HTML but NO intermediate render-input file, audit the RENDERED values directly — read the HTML's drawn values for each expected-UI-slot. Note in evidence that you audited the published HTML.
+
+Return LEAK_SCHEMA with dimension="ui-render".`,
+  },
+  {
+    key: 'data-correctness',
+    prompt: `You are auditing DATA-CORRECTNESS — rendered-value FAITHFULNESS (EV-040): for ANY subject's HTML artifact, is a value present in BOTH the computed data AND the rendered HTML the SAME value, or was it ALTERED / TRUNCATED / re-derived in the UI? Primary bundle dir: ${REPORTS[0]}. READ-ONLY. SUBJECT-AGNOSTIC — spot-check the PROFILE-SUPPLIED expected-UI-slots, NOT hardcoded slot names.
+
+EXPECTED-UI-SLOTS (EV-037, profile-supplied):
+${JSON.stringify(UISLOTS, null, 2)}
+
+DETERMINISTIC EV-039 AUDIT (auditUiSlots — `faithful` findings already mean computed==rendered verbatim; focus your judgment on the NUANCED EV-040 cases the deterministic check can't settle — truncation, rounding, unit-swap, re-derivation):
+${JSON.stringify(UISLOTAUDIT, null, 2)}
+
+Checks (ground EACH in a read of the computed source + the rendered artifact):
+1. Faithfulness (EV-040): for each expected-UI-slot present in BOTH the computed data (trace/runMeta/intermediate) AND the HTML, compare the two values VERBATIM. Identical → note faithful (NO leak). Altered / truncated / rounded / re-derived ad hoc instead of threaded from the script-of-record → leak (locus UI).
+2. Scope-skew: if a rendered aggregate (a count/rate/average) is computed over a small worst-N slice but presented as whole-population → scope-skew leak (cite the slice size vs the population).
+3. Silent drop: a computed value that is null/absent in the HTML while the rest of the artifact implies it should be present → entity/section silent-drop leak.
+HTML-ONLY PATH (first-class): if no intermediate computed file exists, audit faithfulness from the published HTML + any run stamps directly; note you audited the rendered values.
+
+Return LEAK_SCHEMA with dimension="data-correctness".`,
+  },
+  {
+    key: 'context-flow',
+    prompt: `You are auditing the SUBJECT agent's CONTEXT-FLOW (EV-028 tool-result threading + EV-029 sub-agent handoff completeness). Score over the DETERMINISTIC flow-graph (EV-032) + expected-flow (EV-037) supplied below — NOT a raw trace. Follow the context-flow lens at ${CFLENS} (read it). READ-ONLY. SUBJECT-AGNOSTIC: every tool/slot name comes from these structures — invent none.
+
+The flow-graph generalizes the v1 data-pipeline leak SHAPE to an AGENT: an unthreaded tool result is the agent analogue of a runMeta slot a renderer dereferences with no producer; a lossy sub-agent handoff is the analogue of a contract field dropped at a component boundary.
+
+Adjudicate the CANDIDATES (these are candidates — decide which are TRUE leaks + severity; a fully-threaded, expectation-meeting graph yields ZERO leaks):
+1. EV-028 — for each candidate in contextFlowCandidates[].unthreadedOutputs {node,name,slot}: was the dropped producer slot one a later step NEEDED (and silently re-derived / proceeded without)? → leak (locus C2C, cls B). A legitimate side-effect/log with no consumer → NOT a leak.
+2. EV-029 — for each contextFlowCandidates[].lossyHandoffs {fromTool,toTool,slot?}: confirm the expected producer→consumer threading is genuinely absent in flowGraph.edges (not merely renamed). An incomplete dispatch brief that handed a child stale/missing context → leak (locus C2C, cls B). Cite the dispatch node + missing slot.
+Severity HIGH when the dropped/incomplete context changed the agent's action; ground EVERY leak in flow-graph node ids + slot names (evidence field).
+
+EXPECTED-FLOW (EV-037):
+${JSON.stringify(EXPECTEDFLOW, null, 2)}
+
+FLOW-GRAPHS (EV-032, one per audited trace):
+${JSON.stringify(FLOWGRAPHS, null, 2)}
+
+DETERMINISTIC CANDIDATES (per trace):
+${JSON.stringify(CFCANDIDATES, null, 2)}
+
+Return LEAK_SCHEMA with dimension="context-flow".`,
+  },
+]
+
+const dimResultsRaw = await parallel(
+  DIMS.map((d) => () => agent(d.prompt, { label: `audit:${d.key}`, phase: 'Audit dimensions', schema: LEAK_SCHEMA })),
+)
+const dimResults = (dimResultsRaw || []).filter(Boolean)
+
+const allLeaks = dimResults.flatMap((r) => (r.leaks || []).map((l) => ({ ...l, dimension: r.dimension })))
+log(`collected ${allLeaks.length} leaks across ${dimResults.length} dimensions`)
+
+// ── Metrics (deterministic — human-level observability) ──
+const tally = (key) => allLeaks.reduce((m, l) => ((m[l[key]] = (m[l[key]] || 0) + 1), m), {})
+const metrics = {
+  totalLeaks: allLeaks.length,
+  dimensions: dimResults.length,
+  bySeverity: tally('severity'),
+  byLocus: tally('locus'),
+  byClass: tally('cls'),
+  byFormalStructure: tally('formalStructure'),
+  byDimension: tally('dimension'),
+}
+
+phase('Synthesize')
+
+const merged = JSON.stringify({ generatedAt: GEN, dimensions: dimResults.map((r) => ({ dimension: r.dimension, summary: r.summary })), leaks: allLeaks }, null, 2)
+const metricsJson = JSON.stringify(metrics, null, 2)
+
+// The synthesizer renders the Tab-2 fragment using the EVALUATOR's own brand
+// (assets/brand/theme.css — supplied as STYLEREF). NDA: NO client name in the
+// rendered output. The fragment is a <section> the audit.workflow.js inlines.
+const synth = await agent(
+  `Render the Tab-2 (Data-Leak) HTML fragment for the master-audit report. Use the EVALUATOR brand stylesheet at ${STYLEREF} (dark theme + MUTAGENT tokens) — do NOT invent new styling. NO client identity in the output (synthetic names only).
+
+WRITE the fragment to ${OUT}/tab2-data-leak.html. It MUST contain, populated from THIS run's data:
+ 1. A section header "Data-Leak Graph" + a one-line verdict on the headline leaks.
+ 2. A METRICS row of stat tiles (.big-stat) using the EXACT numbers from the metrics JSON (total leaks, HIGH/MED/LOW, C2C/UI, by dimension).
+ 3. A bird's-eye PIPELINE SPINE (raw → normalize → tier0 → slicer → wave6 → analyzer → aggregate → validator → enrich → render) with each leak as a RED-DASHED leaf off its producing stage.
+ 4. The master leak table — columns: ID · Dimension · Locus(C2C/UI) · Producer · Why not produced · Formal structure · What's lost · Sev. One row per leak.
+ 5. A per-dimension detail subsection — ONE subsection per dimension actually present in the merged leak JSON (operational · ui-render · data-correctness · context-flow · any others) — listing each leak with file:line (or flow-graph node:slot) evidence + proposed fix.
+
+METRICS JSON (use exact numbers):
+${metricsJson}
+
+MERGED LEAK JSON:
+${merged}
+
+Return JSON: { written, leakCount, sections }.`,
+  {
+    label: 'synthesize:tab2',
+    phase: 'Synthesize',
+    schema: {
+      type: 'object', additionalProperties: false,
+      properties: { written: { type: 'string' }, leakCount: { type: 'number' }, sections: { type: 'number' } },
+      required: ['written', 'leakCount', 'sections'],
+    },
+  },
+)
+
+return { dimensions: dimResults.length, totalLeaks: allLeaks.length, metrics, synth }

package/mutagent-evaluator/.claude/skills/mutagent-evaluator/workflows/variance.workflow.js

@@ -0,0 +1,163 @@
+/**
+ * workflows/variance.workflow.js  →  Tab-3 (Variance Trend)
+ * ----------------------------------------------------------------------------
+ * SELF-CONTAINED port of the variance-deviance-audit workflow (taken IN, not
+ * referenced). Audits the SUBJECT for inter-run variance, MECE across
+ * SKILL / AGENT / COMMAND scopes, and produces the 15-dim determinism trend.
+ *
+ * GENERIC + subject-agnostic: the subject path + prior-report are supplied via
+ * args. Defaults are SYNTHETIC placeholders — NO production dataset / client is
+ * named (design decision #10). The original hardcoded /Users home path + client
+ * priors have been scrubbed to synthetic equivalents.
+ *
+ * COORDINATOR ROLE (executor ≠ reviewer): this workflow is run by the variance
+ * coordinator, a role distinct from the audit executors. It obeys C-PIN (the
+ * judge is pinned) and the byte-identity masking contract.
+ *
+ * JUDGE-EXECUTION SEAM: `agent()` / `parallel()` / `phase()` are the workflow-
+ * harness DSL; they dispatch the pinned judge. The DETERMINISTIC 15-dim diff
+ * itself is also available fully-wired as scripts/variance-compare.ts — this
+ * workflow adds the MECE defect catalog + adversarial critique on top. Run via
+ * the workflow harness, NOT standalone node.
+ */
+export const meta = {
+  name: 'evaluator-variance',
+  description:
+    'Reproducible variance audit — MECE SKILL/AGENT/COMMAND defect catalog + 15-dim determinism trend → Tab-3',
+  phases: [
+    { title: 'Resolve', detail: 'resolve live subject path + prior artifacts at run time' },
+    { title: 'Catalog', detail: 'parallel defect catalog per scope vs LIVE source' },
+    { title: 'Reconcile', detail: 'MECE dedupe + cross-scope root-cause matrix' },
+    { title: 'Critique', detail: 'adversarial completeness — missing variance sources' },
+    { title: 'Synthesize', detail: 'assemble + render the Tab-3 fragment (15-dim trend)' },
+  ],
+}
+
+let cfg = {}
+if (args && typeof args === 'object') cfg = args
+else if (typeof args === 'string' && args.trim()) { try { cfg = JSON.parse(args) } catch (e) { cfg = {} } }
+const MODE = cfg.mode === 'validate' ? 'validate' : 'full'
+const LABEL = cfg.label || 'ondemand'
+
+// ── Phase 0 — Resolve live targets (robust to worktree drift) ───────────────
+phase('Resolve')
+const RESOLVE_SCHEMA = {
+  type: 'object', additionalProperties: false,
+  required: ['subjectPath', 'subjectPathOk', 'gitCommit', 'priorReportPath', 'priorReportOk', 'reproducible', 'notes'],
+  properties: {
+    subjectPath: { type: 'string' }, subjectPathOk: { type: 'boolean' },
+    gitCommit: { type: 'string' },
+    priorReportPath: { type: 'string' }, priorReportOk: { type: 'boolean' },
+    reproducible: { type: 'boolean' }, notes: { type: 'string' },
+  },
+}
+const resolved = await agent(
+  `Resolve the LIVE audit targets for the SUBJECT variance audit. Use Bash.\n` +
+  `1) subjectPath: ${cfg.subjectPath ? `use "${cfg.subjectPath}"` : 'resolve the subject skill/agent root supplied by the harness'}. Confirm its orchestrator-protocol + a platform normalizer exist (subjectPathOk).\n` +
+  `2) gitCommit: \`git -C <subjectPath> rev-parse --short HEAD\` (else "unknown").\n` +
+  `3) priorReportPath: ${cfg.priorReport ? `use "${cfg.priorReport}"` : 'newest prior variance report supplied by the harness, if any'}; set priorReportOk.\n` +
+  `4) reproducible = subjectPathOk && both key files exist. notes = anything that would make a re-run diverge.\nReturn ONLY the structured result.`,
+  { label: 'resolve', phase: 'Resolve', schema: RESOLVE_SCHEMA },
+)
+log(`Resolve: subject ${resolved.subjectPathOk ? 'OK' : 'MISSING'} @ ${resolved.gitCommit} | prior ${resolved.priorReportOk ? 'found' : 'none'} | reproducible=${resolved.reproducible}`)
+
+if (MODE === 'validate') {
+  return {
+    mode: 'validate', reproducible: resolved.reproducible,
+    subjectPath: resolved.subjectPath, gitCommit: resolved.gitCommit,
+    priorReportPath: resolved.priorReportPath, notes: resolved.notes,
+    message: resolved.reproducible
+      ? 'REPRODUCIBLE — live subject + prior artifacts resolved. Re-run with {mode:"full"} to regenerate the trend.'
+      : 'NOT reproducible right now — see notes.',
+  }
+}
+if (!resolved.reproducible) {
+  log('Aborting full run — targets not resolvable.')
+  return { aborted: true, reason: resolved.notes }
+}
+
+const SUBJECT = resolved.subjectPath
+
+// Regression priors are GENERIC variance archetypes (NOT client findings). The
+// original client-specific priors have been scrubbed to synthetic determinism
+// archetypes so the workflow ships zero NDA content.
+const PRIORS = `
+PRIOR-RUN ARCHETYPES (re-VERIFY each against LIVE source at ${SUBJECT}; status CONFIRMED/FIXED/CHANGED; then find NEW). Synthetic archetypes, NOT a source of truth — live source wins.
+[SKILL] no streaming large-file ingest (OOM risk); handover-contract names-only (no full Finding/Remedy/Assumption JSON-schema); completeness-gate misses the renderer's full deref contract; runMeta/awareness assembly is prose not a script.
+[COMMAND] latency-unit heuristic short-circuits before the span guard; ingest can't stream; unguarded sessionId/escapeBadge dereferences in the renderer; sampler weak worst-bucket weighting with overstated confidence.
+[AGENT] sample-n + analyzer-count recalled from memory not a rule; runMeta/stamps hand-shaped (wrong field names) → render crashes patched reactively; analyzer prompts boolean-coerced fields + no AssumptionSchema.
+[CRITIC] no model/temperature/seed pin (dominant); cwd/timestamp/random unpinned; shared /tmp + existence-only gates (race/stale); no deterministic finding sort; apply-worker unaudited.
+`
+
+const DEFECT_SCHEMA = {
+  type: 'object', additionalProperties: false, required: ['scopeSummary', 'defects'],
+  properties: {
+    scopeSummary: { type: 'string' },
+    defects: { type: 'array', items: { type: 'object', additionalProperties: false,
+      required: ['id','scope','title','locus','class','expected','observed','varianceMechanism','severity','status','evidence','meceNote','remedy','verification'],
+      properties: {
+        id: { type: 'string' }, scope: { type: 'string', enum: ['SKILL','AGENT','COMMAND'] },
+        title: { type: 'string' }, locus: { type: 'string' },
+        class: { type: 'string', enum: ['missing-determinism','code-bug','prose-vs-script-gap','schema-contract-gap','agent-discretion','reactive-improvisation','gate-coverage-gap','capability-gap'] },
+        expected: { type: 'string' }, observed: { type: 'string' }, varianceMechanism: { type: 'string' },
+        severity: { type: 'string', enum: ['P1','P2','P3'] },
+        status: { type: 'string', enum: ['CONFIRMED','FIXED','CHANGED','NEW'] },
+        evidence: { type: 'string' }, meceNote: { type: 'string' }, remedy: { type: 'string' }, verification: { type: 'string' },
+      } } },
+  },
+}
+
+phase('Catalog')
+const scopes = [
+  { key: 'SKILL', brief: "the SUBJECT's DESIGN/SPEC layer: protocol prose, handover-contract, references, templates, config schema, gate COVERAGE, renderer DESIGN, missing scripts. NOT raw code bugs (COMMAND) nor agent judgment (AGENT)." },
+  { key: 'AGENT', brief: "the AGENT ACTORS' runtime BEHAVIOR: judgment calls, improvisation, hand-shaping, protocol deviation, reactive fixes. NOT the code bug (COMMAND) nor the missing spec (SKILL)." },
+  { key: 'COMMAND', brief: "the COMMANDS/SCRIPTS/CLIs themselves: scripts/*.ts, bash/jq, validators as CODE. CODE BUGS / implementation flaws in a runnable unit. NOT the design gap (SKILL) nor the agent workaround (AGENT)." },
+]
+const catalogs = await parallel(scopes.map(s => () =>
+  agent(
+    `You are the ${s.key}-scope auditor for a MECE master audit on INTER-RUN VARIANCE in the SUBJECT (live source at ${SUBJECT}, commit ${resolved.gitCommit}).\nSCOPE: ${s.brief}\n${PRIORS}\nTASK: Read the LIVE source for YOUR scope. Re-verify each prior archetype in your scope vs live source (status CONFIRMED/FIXED/CHANGED), then find NEW defects. Produce a VERBOSE, MUTUALLY-EXCLUSIVE, COLLECTIVELY-EXHAUSTIVE catalog for YOUR scope. Every defect: concrete varianceMechanism + determinism remedy + verification. ids ${s.key}-01.. . Stay strictly in scope; cross-ref via meceNote.`,
+    { label: `catalog:${s.key}`, phase: 'Catalog', schema: DEFECT_SCHEMA, agentType: 'Explore' },
+  ).then(r => ({ scope: s.key, ...r })),
+))
+const valid = catalogs.filter(Boolean)
+log(`Cataloged ${valid.reduce((n,c)=>n+(c.defects?.length||0),0)} defects across ${valid.length} scopes`)
+
+phase('Reconcile')
+const RECON_SCHEMA = {
+  type: 'object', additionalProperties: false, required: ['defects','rootCauseMatrix','meceAttestation','exhaustivenessGaps'],
+  properties: {
+    defects: { type: 'array', items: { type: 'object' } },
+    rootCauseMatrix: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['rootCause','skillDefect','agentDefect','commandDefect','note'], properties: { rootCause:{type:'string'}, skillDefect:{type:'string'}, agentDefect:{type:'string'}, commandDefect:{type:'string'}, note:{type:'string'} } } },
+    meceAttestation: { type: 'string' }, exhaustivenessGaps: { type: 'array', items: { type: 'string' } },
+  },
+}
+const reconciled = await agent(
+  `MECE reconciliation auditor. 3 scope catalogs:\n${JSON.stringify(valid, null, 2)}\nMerge into ONE master list: every defect in EXACTLY ONE scope (code bug→COMMAND; missing/ambiguous spec→SKILL; agent judgment/improvisation→AGENT). Same root cause may spawn one defect per scope — keep all, link in rootCauseMatrix with honest '—'. Carry each defect's status. Renumber ids. Produce rootCauseMatrix, meceAttestation, exhaustivenessGaps.`,
+  { label: 'reconcile', phase: 'Reconcile', schema: RECON_SCHEMA },
+)
+
+phase('Critique')
+const CRIT_SCHEMA = {
+  type: 'object', additionalProperties: false, required: ['missingDefects','boundaryIssues','verdict'],
+  properties: {
+    missingDefects: { type: 'array', items: { type: 'object', additionalProperties: false, required: ['scope','title','varianceMechanism','remedy'], properties: { scope:{type:'string'}, title:{type:'string'}, varianceMechanism:{type:'string'}, remedy:{type:'string'} } } },
+    boundaryIssues: { type: 'array', items: { type: 'string' } }, verdict: { type: 'string' },
+  },
+}
+const critique = await agent(
+  `ADVERSARIAL completeness critic. Goal: minimise inter-run variance. Reconciled set:\n${JSON.stringify(reconciled, null, 2)}\nFind MISSING variance/deviance: LLM non-determinism (temperature/model drift/seed), environment (cwd/clock/file-order), analyzer parallelism races, prompt-cache effects, sampling determinism, silent gate bypasses, partial-failure recovery, apply-worker path, scope-boundary violations. Be skeptical + specific.`,
+  { label: 'critique', phase: 'Critique', schema: CRIT_SCHEMA },
+)
+
+phase('Synthesize')
+// Render the Tab-3 fragment using the EVALUATOR's own brand. The 15-dim trend is
+// the byte-identity scorecard (scripts/variance-compare.ts is the deterministic
+// engine for the diff; this workflow adds the MECE catalog narrative). NDA: NO
+// client identity in the rendered output.
+const synth = await agent(
+  `Render the Tab-3 (Variance Trend) HTML fragment for the master-audit report. Use the EVALUATOR brand (dark theme + MUTAGENT tokens). NO client identity (synthetic names only). Run label: ${LABEL}; subject commit: ${resolved.gitCommit}.\n` +
+  `INPUTS — reconciled:\n${JSON.stringify(reconciled, null, 2)}\nCritique (FOLD IN):\n${JSON.stringify(critique, null, 2)}\n` +
+  `The fragment MUST contain: (1) a header "Variance Trend — Track-2" + the variance thesis + top-3 determinism controls; (2) the fixed 15-dimension determinism scorecard table (dimension · measure · target · divergence) — mark not-evaluated where the run-pair lacked the input; (3) the MECE SKILL/AGENT/COMMAND defect table; (4) the cross-scope root-cause matrix; (5) a Determinism Control Plan (controls grouped, mapped to defects). After writing, reply with: section count + defect count + path.`,
+  { label: 'synthesize:tab3', phase: 'Synthesize' },
+)
+return { label: LABEL, gitCommit: resolved.gitCommit, defectCount: (reconciled.defects||[]).length, gaps: (critique.missingDefects||[]).length, synth }