@hegemonart/get-design-done 1.57.1 → 1.57.3

package/scripts/lib/audit-aggregator/index.cjs

@@ -1,219 +0,0 @@
-/**
- * audit-aggregator/index.cjs — dedup + score + rank findings from N
- * audit-agents (Plan 23-04).
- *
- * Replaces the prompt-only "trust the agent's score" pattern with a
- * deterministic scoring + dedup function that downstream tooling
- * (`/gdd:audit`, `/gdd:reflect`) can rely on.
- *
- * Dedup key: `${lowercased(normalizePath(file))}::${line ?? 0}::${rule_id}`.
- * Survivor selection on collision:
- *   1. higher confidence wins
- *   2. tie → higher severity (P0 > P1 > P2 > P3)
- *   3. tie → lexicographically earliest agent
- *   4. tie → first-seen
- *
- * Score = severityWeight(severity) * confidence.
- *
- * No external deps. CommonJS to match the rest of scripts/lib/.
- */
-
-'use strict';
-
-const SEVERITY_RANK = { P0: 4, P1: 3, P2: 2, P3: 1 };
-const DEFAULT_WEIGHTS = Object.freeze({ P0: 8, P1: 4, P2: 2, P3: 1 });
-
-/**
- * @typedef {Object} Finding
- * @property {string} file
- * @property {number} [line]
- * @property {string} rule_id
- * @property {'P0'|'P1'|'P2'|'P3'} severity
- * @property {string} summary
- * @property {string} [evidence]
- * @property {string} [agent]
- * @property {number} [confidence]
- * @property {string[]} [merged_from]
- */
-
-/**
- * @typedef {Object} AggregateResult
- * @property {Finding[]} findings
- * @property {Object<string, number>} byRule
- * @property {Object<string, number>} bySeverity
- * @property {Object<string, number>} byFile
- * @property {number} total
- * @property {number} duplicates
- */
-
-/**
- * @typedef {Object} AggregateOptions
- * @property {number} [topN]
- * @property {Object<string, number>} [severityWeights]
- * @property {(a: Finding, b: Finding) => Finding} [merge]
- */
-
-function normalizePath(p) {
-  return String(p).replace(/\\/g, '/').toLowerCase();
-}
-
-let _confidenceWarningEmitted = false;
-
-function clampConfidence(c) {
-  if (c === undefined || c === null) return 1;
-  if (typeof c !== 'number' || Number.isNaN(c)) return 1;
-  if (c < 0) {
-    if (!_confidenceWarningEmitted) {
-      process.emitWarning('audit-aggregator: confidence < 0 clamped to 0', 'AuditAggregator');
-      _confidenceWarningEmitted = true;
-    }
-    return 0;
-  }
-  if (c > 1) {
-    if (!_confidenceWarningEmitted) {
-      process.emitWarning('audit-aggregator: confidence > 1 clamped to 1', 'AuditAggregator');
-      _confidenceWarningEmitted = true;
-    }
-    return 1;
-  }
-  return c;
-}
-
-/**
- * Compute score for a finding.
- *
- * @param {Finding} f
- * @param {Object<string, number>} weights
- * @returns {number}
- */
-function score(f, weights) {
-  const w = (weights && weights[f.severity]) ?? DEFAULT_WEIGHTS[f.severity] ?? 0;
-  return w * clampConfidence(f.confidence);
-}
-
-function validateFinding(f, idx) {
-  if (!f || typeof f !== 'object') {
-    throw new TypeError(`audit-aggregator: input[${idx}] is not an object`);
-  }
-  if (typeof f.file !== 'string' || f.file.length === 0) {
-    throw new TypeError(`audit-aggregator: input[${idx}].file is required (non-empty string)`);
-  }
-  if (typeof f.rule_id !== 'string' || f.rule_id.length === 0) {
-    throw new TypeError(`audit-aggregator: input[${idx}].rule_id is required (non-empty string)`);
-  }
-  if (!(f.severity in SEVERITY_RANK)) {
-    throw new TypeError(
-      `audit-aggregator: input[${idx}].severity must be P0|P1|P2|P3 (got ${JSON.stringify(f.severity)})`,
-    );
-  }
-}
-
-function dedupKey(f) {
-  return `${normalizePath(f.file)}::${f.line ?? 0}::${f.rule_id}`;
-}
-
-function defaultMerge(a, b) {
-  // Higher confidence wins.
-  const ca = clampConfidence(a.confidence);
-  const cb = clampConfidence(b.confidence);
-  if (ca !== cb) return ca > cb ? a : b;
-  // Higher severity wins.
-  const ra = SEVERITY_RANK[a.severity];
-  const rb = SEVERITY_RANK[b.severity];
-  if (ra !== rb) return ra > rb ? a : b;
-  // Lexicographic agent.
-  const aa = a.agent ?? '';
-  const ab = b.agent ?? '';
-  if (aa !== ab) return aa < ab ? a : b;
-  // First-seen wins (a is by convention the existing entry).
-  return a;
-}
-
-/**
- * Aggregate findings.
- *
- * @param {Finding[]} input
- * @param {AggregateOptions} [opts]
- * @returns {AggregateResult}
- */
-function aggregate(input, opts = {}) {
-  if (!Array.isArray(input)) {
-    throw new TypeError('audit-aggregator: input must be an array');
-  }
-  // Reset the once-per-call warning flag so a second call can warn again.
-  _confidenceWarningEmitted = false;
-  const merge = typeof opts.merge === 'function' ? opts.merge : defaultMerge;
-  const weights = { ...DEFAULT_WEIGHTS, ...(opts.severityWeights || {}) };
-
-  /** @type {Map<string, Finding>} */
-  const byKey = new Map();
-  let duplicates = 0;
-  for (let i = 0; i < input.length; i++) {
-    validateFinding(input[i], i);
-    const f = { ...input[i] };
-    const key = dedupKey(f);
-    if (byKey.has(key)) {
-      duplicates += 1;
-      const existing = byKey.get(key);
-      const winner = merge(existing, f);
-      const loser = winner === existing ? f : existing;
-      const mergedFrom = new Set(winner.merged_from || []);
-      if (existing.agent && existing !== winner) mergedFrom.add(existing.agent);
-      if (loser.agent && loser !== winner) mergedFrom.add(loser.agent);
-      // Combine prior merged_from too.
-      for (const a of (loser.merged_from || [])) mergedFrom.add(a);
-      winner.merged_from = Array.from(mergedFrom);
-      byKey.set(key, winner);
-    } else {
-      byKey.set(key, f);
-    }
-  }
-
-  const findings = Array.from(byKey.values()).map((f) => ({ ...f, _score: score(f, weights) }));
-  findings.sort((a, b) => {
-    if (a._score !== b._score) return b._score - a._score;
-    const ra = SEVERITY_RANK[a.severity];
-    const rb = SEVERITY_RANK[b.severity];
-    if (ra !== rb) return rb - ra;
-    if (a.file !== b.file) return a.file < b.file ? -1 : 1;
-    return (a.line ?? 0) - (b.line ?? 0);
-  });
-  // Strip the internal _score field before returning.
-  for (const f of findings) delete f._score;
-
-  const truncated = typeof opts.topN === 'number' && opts.topN >= 0
-    ? findings.slice(0, opts.topN)
-    : findings;
-
-  /** @type {Record<string, number>} */
-  const byRule = {};
-  /** @type {Record<string, number>} */
-  const bySeverity = { P0: 0, P1: 0, P2: 0, P3: 0 };
-  /** @type {Record<string, number>} */
-  const byFile = {};
-  for (const f of truncated) {
-    byRule[f.rule_id] = (byRule[f.rule_id] ?? 0) + 1;
-    bySeverity[f.severity] += 1;
-    const k = normalizePath(f.file);
-    byFile[k] = (byFile[k] ?? 0) + 1;
-  }
-
-  return {
-    findings: truncated,
-    byRule,
-    bySeverity,
-    byFile,
-    total: truncated.length,
-    duplicates,
-  };
-}
-
-module.exports = {
-  aggregate,
-  score,
-  normalizePath,
-  dedupKey,
-  defaultMerge,
-  DEFAULT_WEIGHTS,
-  SEVERITY_RANK,
-};

package/scripts/lib/hedge-ensemble.cjs

@@ -1,217 +0,0 @@
-/**
- * hedge-ensemble.cjs — AdaNormalHedge weighted-majority over verifier
- * + checker agents (Plan 23.5-02).
- *
- * Parameter-free: no manual learning rate. Weights self-adapt via
- * the AdaNormalHedge regret-bound trick — η is recomputed each round
- * from cumulative loss variance, eliminating the typical "tune η or
- * suffer" tax.
- *
- * Weights persist at `.design/telemetry/hedge-weights.json` (atomic
- * .tmp + rename). Schema:
- *   { schema_version: '1.0.0',
- *     generated_at: ISO,
- *     pools: { <poolId>: { agents: { <agentId>: {weight, cumLoss, cumLoss2, rounds} } } } }
- *
- * Reused by adaptive_mode = "hedge" or "full" — see Plan 23.5-04.
- */
-
-'use strict';
-
-const fs = require('node:fs');
-const path = require('node:path');
-
-const DEFAULT_WEIGHTS_PATH = '.design/telemetry/hedge-weights.json';
-const SCHEMA_VERSION = '1.0.0';
-const DEFAULT_VOTE_THRESHOLD = 0.5;
-
-function resolvePath(opts = {}) {
-  if (opts.weightsPath) {
-    return path.isAbsolute(opts.weightsPath)
-      ? opts.weightsPath
-      : path.resolve(opts.baseDir ?? process.cwd(), opts.weightsPath);
-  }
-  return path.resolve(opts.baseDir ?? process.cwd(), DEFAULT_WEIGHTS_PATH);
-}
-
-/**
- * @returns {{schema_version: string, generated_at: string, pools: object}}
- */
-function loadWeights(opts = {}) {
-  const p = resolvePath(opts);
-  if (!fs.existsSync(p)) {
-    return { schema_version: SCHEMA_VERSION, generated_at: new Date().toISOString(), pools: {} };
-  }
-  try {
-    const data = JSON.parse(fs.readFileSync(p, 'utf8'));
-    if (!data.pools || typeof data.pools !== 'object') data.pools = {};
-    return data;
-  } catch {
-    return { schema_version: SCHEMA_VERSION, generated_at: new Date().toISOString(), pools: {} };
-  }
-}
-
-function saveWeights(state, opts = {}) {
-  const p = resolvePath(opts);
-  fs.mkdirSync(path.dirname(p), { recursive: true });
-  state.generated_at = new Date().toISOString();
-  const tmp = p + '.tmp';
-  fs.writeFileSync(tmp, JSON.stringify(state, null, 2));
-  fs.renameSync(tmp, p);
-  return p;
-}
-
-function ensurePool(state, poolId) {
-  if (!state.pools[poolId]) state.pools[poolId] = { agents: {} };
-  return state.pools[poolId];
-}
-
-function ensureAgent(pool, agentId) {
-  if (!pool.agents[agentId]) {
-    pool.agents[agentId] = {
-      weight: 1, // uniform start; normalised on read
-      cumLoss: 0,
-      cumLoss2: 0,
-      rounds: 0,
-    };
-  }
-  return pool.agents[agentId];
-}
-
-/**
- * Apply one round of losses to a pool. losses: Record<agentId, lossInZeroOne>.
- *
- * AdaNormalHedge update (parameter-free):
- *   For each agent i:
- *     R_i        = sum of (mean_loss - loss_i) over rounds  (instantaneous regret)
- *     C_i        = sum of (loss_i - mean_loss)^2            (cumulative loss variance)
- *   Set η_i = sqrt(ln(N) / max(1, C_i))  per-agent learning rate.
- *   weight_i ∝ Phi(R_i, C_i) where Phi is a positive-only potential.
- *
- * Simplification used here: w_i *= exp(-η * loss_i) with η derived
- * from cumulative variance — gives the same regret bound as full
- * AdaNormalHedge for the binary-loss case we care about (verifier
- * pass/fail). Trade off: slightly less tight bound vs the full
- * potential, but no need to plumb regret tracking everywhere.
- *
- * @param {{poolId: string, losses: Record<string, number>, baseDir?: string, weightsPath?: string, eta?: number}} input
- * @returns {{weights: Record<string, number>, weightsPath: string}}
- */
-function loss(input) {
-  if (!input || typeof input.poolId !== 'string' || input.poolId.length === 0) {
-    throw new TypeError('hedge-ensemble.loss: poolId (string) required');
-  }
-  if (!input.losses || typeof input.losses !== 'object') {
-    throw new TypeError('hedge-ensemble.loss: losses (Record<string, number>) required');
-  }
-  const state = loadWeights(input);
-  const pool = ensurePool(state, input.poolId);
-  // First, ensure every losing agent exists.
-  for (const [agentId, lossVal] of Object.entries(input.losses)) {
-    if (typeof lossVal !== 'number' || Number.isNaN(lossVal)) {
-      throw new TypeError(`hedge-ensemble.loss: losses.${agentId} must be a number`);
-    }
-  }
-  for (const agentId of Object.keys(input.losses)) {
-    ensureAgent(pool, agentId);
-  }
-  const N = Object.keys(pool.agents).length;
-  // Compute mean loss this round (over agents that received a value).
-  const lossList = Object.values(input.losses);
-  const meanLoss = lossList.length > 0 ? lossList.reduce((a, b) => a + b, 0) / lossList.length : 0;
-  // Update each agent's cumulative variance + regret-like signal, then
-  // recompute its weight via exp(-η_i * loss_i).
-  for (const [agentId, rawLoss] of Object.entries(input.losses)) {
-    const lossVal = Math.min(1, Math.max(0, rawLoss));
-    const a = pool.agents[agentId];
-    const dev = lossVal - meanLoss;
-    a.cumLoss += lossVal;
-    a.cumLoss2 += dev * dev;
-    a.rounds += 1;
-    const eta =
-      typeof input.eta === 'number'
-        ? input.eta
-        : Math.sqrt(Math.log(Math.max(2, N)) / Math.max(1, a.cumLoss2));
-    a.weight *= Math.exp(-eta * lossVal);
-    if (!Number.isFinite(a.weight) || a.weight <= 0) a.weight = 1e-9;
-  }
-  // Renormalize.
-  const total = Object.values(pool.agents).reduce((s, x) => s + x.weight, 0) || 1;
-  /** @type {Record<string, number>} */
-  const out = {};
-  for (const agentId of Object.keys(pool.agents)) {
-    pool.agents[agentId].weight /= total;
-    out[agentId] = pool.agents[agentId].weight;
-  }
-  const writtenPath = saveWeights(state, input);
-  return { weights: out, weightsPath: writtenPath };
-}
-
-/**
- * Compute the weighted-majority verdict for a pool given each agent's
- * binary vote (pass=1, fail=0). Vote passes when the weighted sum
- * exceeds threshold (default 0.5).
- *
- * @param {{poolId: string, votes: Record<string, 0|1|boolean>, threshold?: number, baseDir?: string, weightsPath?: string}} input
- * @returns {{passes: boolean, weighted: number, threshold: number, perAgent: Record<string, {weight: number, vote: number}>}}
- */
-function vote(input) {
-  if (!input || typeof input.poolId !== 'string') {
-    throw new TypeError('hedge-ensemble.vote: poolId required');
-  }
-  if (!input.votes || typeof input.votes !== 'object') {
-    throw new TypeError('hedge-ensemble.vote: votes required');
-  }
-  const state = loadWeights(input);
-  const pool = ensurePool(state, input.poolId);
-  const threshold = typeof input.threshold === 'number' ? input.threshold : DEFAULT_VOTE_THRESHOLD;
-  let total = 0;
-  /** @type {Record<string, {weight: number, vote: number}>} */
-  const perAgent = {};
-  let weightSum = 0;
-  for (const [agentId, raw] of Object.entries(input.votes)) {
-    const v = raw === true || raw === 1 ? 1 : 0;
-    const a = ensureAgent(pool, agentId);
-    perAgent[agentId] = { weight: a.weight, vote: v };
-    total += a.weight * v;
-    weightSum += a.weight;
-  }
-  // Normalise the weighted sum against the SUM of voting agents'
-  // weights — agents in the pool that didn't vote this round don't
-  // dilute the result.
-  const weighted = weightSum > 0 ? total / weightSum : 0;
-  return { passes: weighted >= threshold, weighted, threshold, perAgent };
-}
-
-/**
- * Read current weights for a pool, normalised over the pool's agents.
- *
- * @param {{poolId: string, baseDir?: string, weightsPath?: string}} input
- * @returns {Record<string, number>}
- */
-function weights(input) {
-  if (!input || typeof input.poolId !== 'string') {
-    throw new TypeError('hedge-ensemble.weights: poolId required');
-  }
-  const state = loadWeights(input);
-  const pool = state.pools[input.poolId];
-  if (!pool) return {};
-  const total = Object.values(pool.agents).reduce((s, x) => s + x.weight, 0);
-  /** @type {Record<string, number>} */
-  const out = {};
-  for (const [k, v] of Object.entries(pool.agents)) {
-    out[k] = total > 0 ? v.weight / total : 0;
-  }
-  return out;
-}
-
-module.exports = {
-  loss,
-  vote,
-  weights,
-  loadWeights,
-  saveWeights,
-  DEFAULT_VOTE_THRESHOLD,
-  DEFAULT_WEIGHTS_PATH,
-  SCHEMA_VERSION,
-};

package/skills/discover/SKILL.md

@@ -1,78 +0,0 @@
----
-name: discover
-description: "Stage 1.5 of 4 orchestrator that probes Figma / Refero / Pinterest connections, spawns design-context-builder (auto-detect + interview) and (via lazy gate) design-context-checker (6-dimension validator), producing .design/DESIGN-CONTEXT.md. Use after /gdd:scan when a fast-path context build is wanted instead of the full /gdd:explore. Activates for requests involving detecting an existing design system, inventorying tokens and components, or onboarding a brownfield repo."
-argument-hint: "[--auto] [--incremental] [--full]"
-user-invocable: true
----
-
-# Get Design Done - Discover
-
-**Stage 1.5 of 4.** Produces `.design/DESIGN-CONTEXT.md`.
-
-Full procedure detail: `./discover-procedure.md`.
-
----
-
-## State Integration
-
-1. Read `.design/STATE.md`.
-   - **Missing** -> create minimal skeleton from `reference/STATE-TEMPLATE.md` (stage=discover, status=in_progress, task_progress=0/1) and log warning "STATE.md not found - created fresh. If this is a resumed session, run /get-design-done:scan first."
-   - **Present + stage==discover + status==in_progress** -> RESUME (continue interview; do not reset).
-   - **Otherwise** -> normal transition: set frontmatter stage=discover, `<position>` stage=discover, status=in_progress, task_progress=0/1.
-2. Probe connection availability. ToolSearch runs FIRST (MCP tools may be in the deferred tool set). Run three probes - A (Figma, variant-agnostic with prefix tiebreaker), B (Refero, ToolSearch-only), C (Pinterest, ToolSearch-only). After all probes, write `<connections>` to STATE.md so the builder doesn't re-probe. Full probe specs: `./discover-procedure.md` §Connection Probes.
-3. Update `last_checkpoint`. Write STATE.md.
-
----
-
-## Auto Mode
-
-When `--auto` is passed to the builder: if `tailwind.config.{js,cjs,mjs,ts}` exists -> Tailwind-only project (skip CSS file grep, parse tailwind.config for palette/spacing/font, use those as the baseline style signal). Else fall through to the existing CSS file grep logic. Detail: `./discover-procedure.md` §Auto Mode.
-
----
-
-## Incremental Mode (Phase 53, default)
-
-`--incremental` is the DEFAULT after Phase 53; pass `--full` to opt out and re-map everything. Incremental runs the change classifier FIRST (via the fingerprint store at `.design/fingerprints/`): it fingerprints the current DesignContext graph, diffs each node against the prior cycle, and dispatches mappers per the verdict. SKIP (cosmetic-only / no-op) dispatches 0 mappers; PARTIAL re-maps only the affected community batches; ARCHITECTURE re-batches the dir-reshaped subset; FULL (or `--full`, or a first run with no prior store) re-maps all batches. The batching + classifier engine lives in `explore` (`scripts/lib/explore-parallel-runner` + `scripts/lib/mappers/incremental-discover.cjs`); this flag selects the path. Detail: `./discover-procedure.md` §Incremental Mode.
-
----
-
-## Step 1 - Spawn design-context-builder
-
-Spawn `design-context-builder` -> `.design/DESIGN-CONTEXT.md`. The agent auto-detects via grep/glob first and interviews only for areas where auto-detect returned no confident answer. Baseline audit directory chain: `src/` -> `app/` -> `pages/` -> `lib/` -> flag "layout unknown". Common gray areas to probe (Area 7): font-change risk, token-layer introduction risk, component rebuild-vs-restyle. Wait for `## CONTEXT COMPLETE`, then update STATE.md `task_progress = 0.5`. Full prompt: `./discover-procedure.md` §Step 1.
-
----
-
-## Step 1.75 - Lazy gate: should design-context-checker run? (Plan 10.1-04, D-21)
-
-Spawn the cheap Haiku gate `design-context-checker-gate` before the full checker. It applies the single-file heuristic (is `DESIGN-CONTEXT.md` in `git diff --name-only HEAD~1..HEAD`?) and emits JSON + `## GATE COMPLETE`. On `spawn: false`: append `lazy_skipped: true` telemetry row, skip Step 2, set STATE.md `<position>` as if checker passed. On `spawn: true`: proceed to Step 2. On first-run discover the gate always returns `spawn: true` (builder just wrote the file); the gate meaningfully short-circuits only on re-runs where the builder made no changes. Full prompt: `./discover-procedure.md` §Step 1.75.
-
-**Parallel synthesizer note:** discover does not spawn parallel researchers in v1, so `skills/synthesize/` is not wired here. If future variants spawn N parallel interviewers, wire synthesize between dispatch and collate as in `skills/map/` Step 3.5.
-
----
-
-## Step 2 - Spawn design-context-checker
-
-Spawn `design-context-checker` with `<required_reading>` on STATE.md + DESIGN-CONTEXT.md. The agent validates DESIGN-CONTEXT.md across 6 dimensions and returns APPROVED or BLOCKED with per-dimension verdicts. Wait for `## CONTEXT CHECK COMPLETE`. Full prompt: `./discover-procedure.md` §Step 2.
-
----
-
-## Step 3 - Handle checker verdict
-
-- **APPROVED** -> proceed to state update.
-- **BLOCKED** -> present blocked dimensions to user, offer fix-and-retry loop (re-spawn builder with specific fix instructions). Do not proceed to planning.
-
----
-
-## State Update (exit)
-
-1. Set `<position>` `status=completed`, `task_progress=1/1`.
-2. Set `<timestamps>` `discover_completed_at=<ISO 8601 now>`.
-3. Update `last_checkpoint`. Write STATE.md.
-
----
-
-## After Writing
-
-Print the "=== Discovery complete ===" block with saved path, baseline score, top key issues, and next step (`/get-design-done:plan`). Do not proceed to planning automatically unless `--auto` was passed. Template: `./discover-procedure.md` §After Writing.
-
-## DISCOVER COMPLETE