aw-spec-cli 0.1.4 → 0.1.5

package/assets/docs/domainspecs/UIVisualization/chart-heatmap.md

@@ -1,62 +0,0 @@
-# Heatmap — Chart Rule
-
-> Load **only when "Heatmap" (or "all plots") is in the selection** (see [[domain-requirements]]).
-> Component: `Heatmap` in `components/charts/generic/Heatmap.tsx`. Built on [[charting-standards.domain]].
-
-## Purpose
-Colour-encoded grid for a 2-D value matrix. Use for correlation matrices, expression grids
-(log₂FC), confusion matrices, risk tables, cross-asset return grids.
-
-## Props contract
-```ts
-type ColourPreset = 'diverging-purple-red' | 'sequential-teal' | 'sequential-heat' | 'diverging-blue-red'
-
-interface HeatmapProps {
-  matrix: number[][]            // matrix[row][col] — REQUIRED
-  rowLabels: string[]           // y-axis — REQUIRED
-  colLabels: string[]           // x-axis — REQUIRED
-  title?: string
-  unit?: string                 // colour-bar title + tooltip unit (e.g. "log₂FC", "r")
-  colorscale?: ColourPreset | [number, string][]   // default 'diverging-purple-red'
-  zMid?: number                 // centre of a diverging scale (use 0 for FC / correlation)
-  zMin?: number; zMax?: number  // override colour range (defaults to matrix min/max)
-  showCellValues?: boolean      // annotate each cell (default true)
-  cellValuePrecision?: number   // decimals in annotations (default 2)
-  cellValueContrastThreshold?: number  // |value| above → white text (default 1.0)
-  height?: number               // omit for responsive fill
-  reverseRows?: boolean
-}
-```
-
-## Rules
-- `matrix.length === rowLabels.length`; every row length `=== colLabels.length`. Validate in the
-  adapter, not the chart.
-- For **diverging** data (fold-change, correlation) set `zMid={0}` so zero maps to the neutral
-  midpoint; for **sequential** data (counts, intensity) use a `sequential-*` preset and omit `zMid`.
-- Keep cell annotations on for ≤ ~12×12 grids; turn `showCellValues` off for dense matrices.
-
-## Adapter example (agent reference)
-```tsx
-'use client'
-import { Heatmap } from '@/components/charts/generic'
-import type { BiomarkerData } from '@/lib/types/pharma'
-
-export default function BiomarkerHeatmap({ data, height }: { data: BiomarkerData; height?: number }) {
-  return (
-    <Heatmap
-      matrix={data.matrix} rowLabels={data.treatments} colLabels={data.markers}
-      unit="log₂FC" colorscale="diverging-purple-red" zMid={0}
-      showCellValues cellValuePrecision={2} cellValueContrastThreshold={1.5}
-      height={height}
-    />
-  )
-}
-```
-
-## Scaffolds when selected
-- `components/charts/generic/Heatmap.tsx` (from the generic library — always present)
-- `app/heatmap/page.tsx` (example route) + nav tab
-- optional adapter `components/charts/<Domain>Heatmap.tsx`
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-network.md

@@ -1,69 +0,0 @@
-# NetworkGraph — Chart Rule
-
-> Load **only when "Network / graph / node-edge" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `NetworkGraph` in `components/charts/generic/NetworkGraph.tsx`. Built on [[charting-standards.domain]].
-
-## Purpose
-Force-directed **node-edge** graph rendered with Plotly scatter+line traces; layout is computed
-in-component (Fruchterman-Reingold spring or circular) so **no extra graph library** is needed.
-Use for PPI/pathway networks, microservice/dependency maps, knowledge graphs, org/social graphs.
-
-## Props contract
-```ts
-interface NetworkNode {
-  id: string                   // referenced by edges
-  label: string
-  group?: string               // colour + legend
-  size?: number                // marker size (importance, default 10)
-  meta?: Record<string, string|number>
-}
-interface NetworkEdge {
-  source: string; target: string   // node ids
-  weight?: number              // line thickness (default 1)
-  label?: string               // hover label
-}
-interface NetworkGraphProps {
-  nodes: NetworkNode[]; edges: NetworkEdge[]   // REQUIRED
-  layout?: 'spring' | 'circular'   // default 'spring'
-  springIterations?: number    // default 120 (higher = better layout, slower)
-  showEdgeLabels?: boolean      // default true
-  directed?: boolean            // arrowheads (default false)
-  title?: string; height?: number
-}
-```
-
-## Rules
-- Every edge `source`/`target` MUST reference an existing node `id`. Validate in the adapter;
-  dangling edges are dropped silently.
-- Layout is **deterministic per dataset** (warm-started from a circle) but recomputes when the
-  node/edge set changes — memoise `nodes`/`edges` so it doesn't recompute each render.
-- Keep graphs modest (≲ ~150 nodes) for readable spring layout; above that, pre-cluster or paginate.
-- Set `directed` for DAGs / signalling cascades; leave off for undirected association graphs.
-
-## Page/adapter example (agent reference)
-```tsx
-'use client'
-import { NetworkGraph } from '@/components/charts/generic'
-import type { NetworkNode, NetworkEdge } from '@/components/charts/generic'
-
-const NODES: NetworkNode[] = [
-  { id: 'EGFR', label: 'EGFR', group: 'Receptor', size: 26 },
-  { id: 'RAS',  label: 'RAS',  group: 'GTPase',   size: 22 },
-  { id: 'RAF',  label: 'BRAF', group: 'Kinase',   size: 20 },
-]
-const EDGES: NetworkEdge[] = [
-  { source: 'EGFR', target: 'RAS', weight: 2.5, label: 'activates' },
-  { source: 'RAS',  target: 'RAF', weight: 2,   label: 'activates' },
-]
-
-export default function PathwayNetwork() {
-  return <NetworkGraph nodes={NODES} edges={EDGES} layout="spring" springIterations={150} directed showEdgeLabels />
-}
-```
-
-## Scaffolds when selected
-- generic `NetworkGraph` + `app/network/page.tsx` + nav tab + optional adapter; type the node/edge
-  arrays with `NetworkNode[]` / `NetworkEdge[]` to avoid `meta` literal-type errors.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-parallel.md

@@ -1,75 +0,0 @@
-# ParallelCoordinatesPlot — Chart Rule
-
-> Load **only when "Parallel Coords / parcoords" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `ParallelCoordinatesPlot` in `components/charts/generic/ParallelCoordinatesPlot.tsx`.
-> Built on [[charting-standards.domain]]; uses Plotly's native `parcoords` (interactive axis brushing).
-
-## Purpose
-Multi-dimensional data as **polylines crossing parallel vertical axes** — one line per observation.
-Use for multi-parameter optimisation (MPO), ADMET profiles, hyperparameter sweeps, KPI dashboards,
-portfolio metrics.
-
-## Props contract
-```ts
-interface PCDimension {
-  key: string                  // matches a key in each trace's `values`
-  label: string
-  range?: [number, number]     // axis range (auto if omitted)
-  tickFormat?: string          // d3 format, e.g. ".2f", ".0f"
-  invertAxis?: boolean         // for "lower is better" metrics (IC₅₀, p-value)
-}
-interface PCTrace {
-  id: string; label: string
-  colorValue: number           // drives the line colour (continuous)
-  values: Record<string, number>   // one value per dimension key
-  group?: string
-}
-type PCColorscale = 'teal-purple' | 'blue-red' | 'viridis' | 'plasma' | [number, string][]
-
-interface ParallelCoordinatesPlotProps {
-  dimensions: PCDimension[]    // REQUIRED — the axes
-  traces: PCTrace[]            // REQUIRED — one per observation
-  colorLabel?: string          // colour-bar title
-  colorscale?: PCColorscale    // default 'teal-purple'
-  lineOpacity?: number; lineWidth?: number
-  title?: string; height?: number
-}
-```
-
-## Rules
-- `dimensions[].key` must exist in **every** trace's `values`. Validate in the adapter.
-- Use `invertAxis` for metrics where **lower is better** so "good" lines trend the same way.
-- `colorValue` is a single continuous dimension (often the headline metric, e.g. IC₅₀ or score);
-  it maps onto `colorscale`. Brushing on any axis filters interactively — no extra wiring.
-
-## Page/adapter example (agent reference)
-```tsx
-'use client'
-import { ParallelCoordinatesPlot } from '@/components/charts/generic'
-import type { Compound } from '@/lib/types/pharma'
-
-const DIMS = [
-  { key: 'mw',   label: 'MW (Da)',   range: [300, 560] as [number, number], tickFormat: '.0f' },
-  { key: 'logP', label: 'LogP',      range: [1.5, 5.5] as [number, number], tickFormat: '.1f' },
-  { key: 'ic50', label: 'IC₅₀ (nM)', range: [0, 800]   as [number, number], tickFormat: '.0f', invertAxis: true },
-]
-
-export default function MpoParallel({ compounds }: { compounds: Compound[] }) {
-  return (
-    <ParallelCoordinatesPlot
-      dimensions={DIMS}
-      traces={compounds.filter(c => c.ic50_nM <= 800).map(c => ({
-        id: c.id, label: c.name, group: c.status, colorValue: c.ic50_nM,
-        values: { mw: c.molecularWeight, logP: c.logP, ic50: c.ic50_nM },
-      }))}
-      colorLabel="IC₅₀ (nM)" colorscale="teal-purple"
-    />
-  )
-}
-```
-
-## Scaffolds when selected
-- generic `ParallelCoordinatesPlot` + `app/parallel/page.tsx` + nav tab + optional adapter.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-scurve.md

@@ -1,66 +0,0 @@
-# SCurveChart — Chart Rule
-
-> Load **only when "S-Curve / dose-response / sigmoid" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `SCurveChart` in `components/charts/generic/SCurveChart.tsx`. Built on [[charting-standards.domain]].
-
-## Purpose
-One or more **sigmoidal (S-shaped)** curves with optional inflection markers. Use for
-dose-response (4-PL / Hill), technology adoption, market penetration, enzyme kinetics, SaaS ramp.
-
-## Props contract
-```ts
-interface SCurvePoint { x: number; y: number }
-interface SCurve {
-  id: string; label: string; color?: string
-  points: SCurvePoint[]        // PRE-COMPUTED by the caller (model runs outside the chart)
-  inflectionX?: number         // e.g. IC₅₀ / midpoint — draws a marker + dashed line
-  inflectionLabel?: string     // "IC₅₀", "EC₅₀", "Midpoint", "Tipping point"
-  metadata?: Record<string, string>  // tooltip enrichment
-}
-interface SCurveChartProps {
-  curves: SCurve[]             // REQUIRED
-  xLabel: string; yLabel: string   // REQUIRED
-  xAxisType?: 'linear' | 'log'
-  referenceY?: number          // horizontal reference (default 50)
-  referenceYLabel?: string
-  yRange?: [number, number]    // default [-5, 108]
-  title?: string; height?: number
-}
-```
-
-## Rules
-- The chart **plots points, it does not fit models** — the caller generates curve points (4-PL,
-  logistic, etc.) and passes them. Provide generators in `lib/utils.ts`
-  (`generate4PLCurve`, `generateLogisticPoints`).
-- `inflectionX` is in the **same x-units** as the points (e.g. `log10(ic50_nM)` if x is log-conc).
-- Use `referenceY={50}` for "50% response/adoption"; set to `undefined` to hide.
-
-## Adapter example (agent reference)
-```tsx
-'use client'
-import { SCurveChart } from '@/components/charts/generic'
-import { PHARMA_COLORS } from '@/components/charts/PlotlyChart'
-import type { DoseResponseCurve } from '@/lib/types/pharma'
-
-export default function DoseResponseChart({ curves, height }: { curves: DoseResponseCurve[]; height?: number }) {
-  return (
-    <SCurveChart
-      curves={curves.map((c, i) => ({
-        id: c.compoundId, label: c.compoundName, color: PHARMA_COLORS[i % PHARMA_COLORS.length],
-        points: c.points.map(p => ({ x: p.logConc, y: p.response })),
-        inflectionX: Math.log10(c.ic50_nM), inflectionLabel: 'IC₅₀',
-        metadata: { Target: c.target, 'Hill slope': c.hillSlope.toFixed(2) },
-      }))}
-      xLabel="log₁₀[Concentration (nM)]" yLabel="% Inhibition"
-      referenceY={50} referenceYLabel="50% Inhibition" height={height}
-    />
-  )
-}
-```
-
-## Scaffolds when selected
-- generic `SCurveChart` + curve generators in `lib/utils.ts` + `app/scurve/` (or `dose-response/`)
-  route + nav tab + optional adapter.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-survival.md

@@ -1,69 +0,0 @@
-# SurvivalCurveChart — Chart Rule
-
-> Load **only when "Survival / Kaplan-Meier / retention" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `SurvivalCurveChart` in `components/charts/generic/SurvivalCurveChart.tsx`. Built on [[charting-standards.domain]].
-
-## Purpose
-Kaplan-Meier–style **step-function** curves with optional CI shading, median markers, and a
-significance annotation. Use for clinical OS/PFS, user-cohort retention, component MTTF, churn.
-
-## Props contract
-```ts
-interface SurvivalPoint {
-  time: number
-  survival: number             // 0–1 (×100 applied) or 0–100
-  ciLower?: number; ciUpper?: number   // same scale as survival
-  nAtRisk?: number
-}
-interface SurvivalArm {
-  label: string; color: string        // colour REQUIRED — distinguishes arms
-  points: SurvivalPoint[]
-  medianTime?: number | null          // null = not reached
-}
-interface SurvivalCurveChartProps {
-  arms: SurvivalArm[]          // REQUIRED
-  timeLabel?: string           // default "Time"
-  survivalLabel?: string       // default "Survival Probability (%)"
-  eventLabel?: string          // "Death", "Churn", "Failure" …
-  medianLabel?: string         // "mOS", "mPFS", "Median retention"
-  curveType?: string           // corner badge: "OS", "KM", "Retention"
-  pValue?: string              // "< 0.001", "n.s."
-  showCI?: boolean             // default true (needs ciLower/ciUpper)
-  xMax?: number; height?: number
-}
-```
-
-## Rules
-- Curve is a **step function** (`shape: 'hv'`) — survival is constant between events. Pass points
-  at event/censor times; the chart draws the steps.
-- `survival` accepts either 0–1 or 0–100 — the chart normalises; be consistent within an arm.
-- CI shading requires `ciLower`/`ciUpper` on the points and `showCI` (default on).
-- `medianTime: null` renders "Not reached" — use it, don't fake a value.
-
-## Adapter example (agent reference)
-```tsx
-'use client'
-import { SurvivalCurveChart } from '@/components/charts/generic'
-import type { TrialArm } from '@/lib/types/pharma'
-
-export default function KaplanMeierChart({ arms, height }: { arms: TrialArm[]; height?: number }) {
-  return (
-    <SurvivalCurveChart
-      arms={arms.map(a => ({
-        label: a.name, color: a.color, medianTime: a.medianSurvival,
-        points: a.points.map(p => ({ time: p.time, survival: p.survival,
-          ciLower: p.ciLower, ciUpper: p.ciUpper, nAtRisk: p.nAtRisk })),
-      }))}
-      timeLabel="Days" survivalLabel="Survival Probability (%)" medianLabel="mOS"
-      curveType="OS" pValue="< 0.001" showCI height={height}
-    />
-  )
-}
-```
-
-## Scaffolds when selected
-- generic `SurvivalCurveChart` + `app/survival/` (or `trials/`) route + nav tab + optional adapter;
-  an optional number-at-risk table consumes `nAtRisk`.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-trellis.md

@@ -1,68 +0,0 @@
-# TrellisGrid — Chart Rule
-
-> Load **only when "Trellis / facet / small-multiples" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `TrellisGrid` in `components/charts/generic/TrellisGrid.tsx`. Built on [[charting-standards.domain]];
-> uses Plotly subplot `grid`.
-
-## Purpose
-An **N×M grid of the same chart type** — one panel per data subset (small multiples / facets).
-Use for KPI by region, IC₅₀ by target class, sensor readings by machine, feature distributions
-per class.
-
-## Props contract
-```ts
-interface TrellisTrace {
-  type: 'bar' | 'scatter' | 'line' | 'box'
-  x: (string|number)[]; y: number[]
-  label: string; color?: string
-  mode?: 'markers' | 'lines' | 'lines+markers'   // scatter/line only
-}
-interface TrellisPanel { title: string; traces: TrellisTrace[] }
-
-interface TrellisGridProps {
-  panels: TrellisPanel[]       // REQUIRED — one per subset
-  cols?: number                // grid columns (default 3); rows auto
-  xLabel?: string; yLabel?: string   // shared axis labels
-  sharedXAxis?: boolean        // align x-range across panels
-  sharedYAxis?: boolean        // align y-range — ESSENTIAL for fair comparison
-  panelHeight?: number         // px per panel (total = rows × panelHeight)
-  title?: string
-}
-```
-
-## Rules
-- All panels render the **same trace type** — that is the point of small multiples. Don't mix bar
-  and line across panels.
-- Turn on **`sharedYAxis`** whenever comparing magnitudes across panels — otherwise each panel
-  auto-scales and the comparison misleads.
-- `panels` is built by grouping the dataset on the facet dimension (target, region, class) in the
-  adapter/page.
-- `TrellisGrid` sizes by `rows × panelHeight` (it does not fill-parent); pick `panelHeight` for the
-  card and let the page scroll if needed.
-
-## Page/adapter example (agent reference)
-```tsx
-'use client'
-import { TrellisGrid } from '@/components/charts/generic'
-import { PHARMA_COLORS } from '@/components/charts/PlotlyChart'
-import type { Compound } from '@/lib/types/pharma'
-
-export default function Ic50ByTarget({ compounds }: { compounds: Compound[] }) {
-  const targets = [...new Set(compounds.map(c => c.target))]
-  const panels = targets.map((t, i) => {
-    const g = compounds.filter(c => c.target === t).sort((a, b) => a.ic50_nM - b.ic50_nM)
-    return {
-      title: t,
-      traces: [{ type: 'bar' as const, label: t, color: PHARMA_COLORS[i % PHARMA_COLORS.length],
-        x: g.map(c => c.name), y: g.map(c => Math.min(c.ic50_nM, 800)) }],
-    }
-  })
-  return <TrellisGrid panels={panels} cols={4} xLabel="Compound" yLabel="IC₅₀ (nM)" sharedYAxis panelHeight={210} />
-}
-```
-
-## Scaffolds when selected
-- generic `TrellisGrid` + `app/trellis/page.tsx` + nav tab + optional adapter.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-violin.md

@@ -1,61 +0,0 @@
-# ViolinPlot — Chart Rule
-
-> Load **only when "Violin / distribution" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `ViolinPlot` in `components/charts/generic/ViolinPlot.tsx`.
-> Built on [[charting-standards.domain]]; uses Plotly's native `violin` (KDE + box computed for you).
-
-## Purpose
-Distribution **shape (KDE)** of a numeric variable across groups, with optional box plot and
-jittered points. Use for biomarker expression by cohort, API latency by endpoint, salary by band,
-any group-wise distribution comparison.
-
-## Props contract
-```ts
-interface ViolinGroup {
-  label: string                // x-axis category
-  values: number[]             // RAW observations — Plotly computes KDE/IQR/whiskers
-  color?: string
-}
-type PointDisplayMode = 'none' | 'outliers' | 'all' | 'suspected'
-
-interface ViolinPlotProps {
-  groups: ViolinGroup[]        // REQUIRED
-  yLabel?: string; xLabel?: string
-  showBox?: boolean            // overlay median/IQR box (default true)
-  showMean?: boolean           // mean line (default false)
-  showPoints?: PointDisplayMode // default 'outliers'
-  side?: 'both' | 'positive' | 'negative'  // split violin for back-to-back compare
-  bandwidth?: 'normal reference' | 'scott' | 'silverman'
-  fillOpacity?: number
-  title?: string; height?: number
-}
-```
-
-## Rules
-- Pass **raw values** — never pre-binned or pre-summarised; the chart computes KDE, quartiles and
-  whiskers. Each group needs enough points (≥ ~10) for a meaningful KDE.
-- Use `showPoints="outliers"` for clinical/quality data; `"all"` only for small n.
-- `side="positive"`/`"negative"` enables split (back-to-back) violins for two-condition compares.
-
-## Page/adapter example (agent reference)
-```tsx
-'use client'
-import { ViolinPlot } from '@/components/charts/generic'
-
-// readings: { group: string; value: number }[]
-export default function ExpressionViolin({ readings }: { readings: { group: string; value: number }[] }) {
-  const groups = [...new Set(readings.map(r => r.group))].map(g => ({
-    label: g, values: readings.filter(r => r.group === g).map(r => r.value),
-  }))
-  return (
-    <ViolinPlot groups={groups} yLabel="Expression (log₂FC)" xLabel="Treatment"
-      showBox showMean showPoints="outliers" />
-  )
-}
-```
-
-## Scaffolds when selected
-- generic `ViolinPlot` + `app/violin/page.tsx` + nav tab + optional adapter.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/chart-volcano.md

@@ -1,63 +0,0 @@
-# VolcanoPlot — Chart Rule
-
-> Load **only when "Volcano" (or "all plots") is selected** (see [[domain-requirements]]).
-> Component: `VolcanoPlot` in `components/charts/generic/VolcanoPlot.tsx`. Built on [[charting-standards.domain]].
-
-## Purpose
-**Magnitude vs. significance** scatter, partitioned into up / down / not-significant by two
-thresholds. Use for differential expression (RNA-seq/proteomics), A/B-test lift vs significance,
-GWAS hits, ML feature importance, adverse-event signals.
-
-## Props contract
-```ts
-interface VolcanoPoint {
-  x: number                    // magnitude (e.g. log₂FC, effect size)
-  y: number                    // significance (e.g. -log₁₀ p-value)
-  label: string
-  meta?: Record<string, string|number>
-}
-interface VolcanoPlotProps {
-  points: VolcanoPoint[]       // REQUIRED
-  xLabel?: string              // default "log₂(Fold Change)"
-  yLabel?: string              // default "-log₁₀(p-value)"
-  foldChangeThreshold?: number // |x| above → "changed" (default 1.0)
-  significanceThreshold?: number // y above → significant (default 1.301 ≈ p<0.05)
-  upColor?: string; downColor?: string; nsColor?: string
-  upLabel?: string; downLabel?: string; nsLabel?: string
-  labelTopN?: number           // annotate top-N by |x·y| (default 10; 0 disables)
-  title?: string; height?: number
-}
-```
-
-## Rules
-- The caller supplies **already-computed** statistics: `x` = effect/log₂FC, `y` = `-log10(p)`.
-  The chart does not run the test.
-- `significanceThreshold` is in **`-log10(p)`** units (1.301 = p 0.05; 2 = p 0.01). State the test
-  basis in `yLabel`.
-- The chart partitions points by the two thresholds and labels the top-N hits — keep `labelTopN`
-  small (≤ 15) to avoid clutter.
-
-## Page/adapter example (agent reference)
-```tsx
-'use client'
-import { VolcanoPlot } from '@/components/charts/generic'
-
-// genes: { name, log2FC, pValue }[]
-export default function DiffExpressionVolcano({ genes }: { genes: { name: string; log2FC: number; pValue: number }[] }) {
-  return (
-    <VolcanoPlot
-      points={genes.map(g => ({ x: g.log2FC, y: -Math.log10(g.pValue), label: g.name,
-        meta: { 'p-value': g.pValue.toExponential(2) } }))}
-      xLabel="log₂(Fold Change)" yLabel="-log₁₀(p-value)"
-      foldChangeThreshold={1} significanceThreshold={1.301}
-      upLabel="Up-regulated" downLabel="Down-regulated" labelTopN={10}
-    />
-  )
-}
-```
-
-## Scaffolds when selected
-- generic `VolcanoPlot` + `app/volcano/page.tsx` + nav tab + optional adapter.
-
-## Related
-- [[charting-standards.domain]] · [[component-contracts.domain]] · [[clean-architecture.domain]]

package/assets/docs/domainspecs/UIVisualization/charting-standards.domain.md

@@ -1,80 +0,0 @@
-# Charting Standards — UI Visualization Domain
-
-> The base Plotly wrapper, theme, and rendering rules every chart depends on. NON-NEGOTIABLE.
-> Commands: `/aw-spec-plan`, `/aw-spec-tasks`, `/aw-spec-implement`.
-
-## Single base wrapper
-
-- **All** charts render through one component: `components/charts/PlotlyChart.tsx`. No chart imports
-  `plotly.js` directly.
-- Plotly is loaded via **dynamic import inside `useEffect`** (SSR-safe — Plotly touches `window`).
-  Never import it at module top level; never render it in a Server Component.
-- The wrapper exposes a shared `BASE_LAYOUT`, `BASE_CONFIG`, and `PHARMA_COLORS` palette that every
-  generic chart spreads over its own layout.
-- **Responsive fill:** when a chart is given no explicit `height`, it passes `fillHeight` and the
-  wrapper sizes to the parent (`height: 100%`); when given a number, that wins. Charts therefore
-  fill a flex card without manual measuring.
-
-## Canonical base wrapper (agent reference)
-
-```tsx
-// components/charts/PlotlyChart.tsx
-'use client'
-import { useEffect, useRef } from 'react'
-
-export const PHARMA_COLORS = ['#00d4b4','#3b82f6','#8b5cf6','#f59e0b','#ef4444','#10b981','#f97316','#ec4899']
-export const BASE_LAYOUT = {
-  paper_bgcolor: '#0a1628', plot_bgcolor: '#0a1628',
-  font: { color: '#8ba3c7', family: 'Inter, system-ui, sans-serif', size: 11 },
-  margin: { t: 30, r: 20, b: 50, l: 60 },
-  xaxis: { gridcolor: 'rgba(59,130,246,0.10)', zerolinecolor: 'rgba(59,130,246,0.10)' },
-  yaxis: { gridcolor: 'rgba(59,130,246,0.10)', zerolinecolor: 'rgba(59,130,246,0.10)' },
-  hoverlabel: { bgcolor: '#0f1e38', bordercolor: 'rgba(0,212,180,0.3)', font: { color: '#e2ecff' } },
-}
-export const BASE_CONFIG = { displayModeBar: true, displaylogo: false, responsive: true }
-
-interface Props { data: unknown[]; layout?: Record<string, unknown>; config?: Record<string, unknown>; className?: string; fillHeight?: boolean }
-
-export default function PlotlyChart({ data, layout = {}, config = {}, className, fillHeight = false }: Props) {
-  const ref = useRef<HTMLDivElement>(null)
-  useEffect(() => {
-    if (!ref.current) return
-    const el = ref.current; let cancelled = false
-    import('plotly.js-dist-min').then(Plotly => {
-      if (cancelled || !el) return
-      Plotly.react(el, data, { ...BASE_LAYOUT, ...layout }, { ...BASE_CONFIG, ...config })
-    })
-    return () => { cancelled = true; import('plotly.js-dist-min').then(P => { try { P.purge(el) } catch {} }) }
-    // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [JSON.stringify(data), JSON.stringify(layout)])
-  return <div ref={ref} className={className} style={{ width: '100%', height: fillHeight ? '100%' : undefined }} />
-}
-```
-
-## Generic-chart contract (every chart in `generic/`)
-
-1. `'use client'` at the top; renders only via `PlotlyChart`.
-2. Accepts an **optional `height?: number`**; spreads `height` into layout only when defined,
-   else passes `fillHeight={height === undefined}` and adds `h-full` to the className.
-3. Builds `data` + `layout` from props, spreading `BASE_LAYOUT`.
-4. **No domain vocabulary** — all labels/units/colours come from props
-   (see [[component-contracts.domain]]).
-5. Colours default from `PHARMA_COLORS` (rename palette per project; keep the export name stable).
-
-## Theme tokens
-
-- Dark "glass" theme: `bg-mesh` background, `glass-card` + `gradient-border` chart cards,
-  accent teal `#00d4b4` / purple `#7c3aed`. Tokens live in `globals.css` and `tailwind.config.ts`.
-- Chart text/grid colours come from `BASE_LAYOUT` so every chart matches the shell automatically.
-
-## Rules
-
-- Purge the Plotly instance on unmount (the wrapper does this) to avoid leaks on route change.
-- Re-render keys off `JSON.stringify(data/layout)` — keep prop objects stable or memoised for
-  large datasets.
-- Never set a fixed pixel height in a page card; let `fillHeight` size to the flex parent.
-
-## Related
-- [[component-contracts.domain]] — the per-chart prop contract built on this base
-- [[clean-architecture.domain]] — the generic ring depends only on this wrapper
-- All `chart-*` rule files build on this base.