@opengsd/gsd-core 1.4.0-rc.1 → 1.4.0

package/scripts/issue-dedupe.cjs

@@ -0,0 +1,278 @@
+#!/usr/bin/env node
+'use strict';
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const POSSIBLE_DUPLICATE_LABEL = 'possible-duplicate';
+const HUMAN_REVIEW_LABEL = 'needs-maintainer-review';
+const CHALLENGE_MARKER = '<!-- gsd-dedupe-challenge -->';
+const DEFAULT_WINDOW_HOURS = 24;
+const DEFAULT_THRESHOLD = 0.6;
+const DEFAULT_MAX_CANDIDATES = 5;
+const MIN_TOKEN_LENGTH = 3;
+
+const EXEMPT_LABELS = [
+  'priority: critical',
+  'pinned',
+  'confirmed-bug',
+  'confirmed',
+  'fix-pending',
+  'needs-maintainer-review',
+];
+
+const STOPWORDS = new Set([
+  'the', 'a', 'an', 'and', 'or', 'but', 'if', 'then', 'is', 'are', 'was',
+  'be', 'to', 'of', 'in', 'on', 'for', 'with', 'as', 'at', 'by', 'from',
+  'this', 'that', 'it', 'its', 'not', 'no', 'when', 'what', 'why', 'how',
+  'does', 'do', 'doing', 'did', 'can', 'will', 'would', 'should',
+  'i', 'we', 'you', 'your', 'my', 'me',
+  'issue', 'bug', 'error', 'problem', 'feature', 'request',
+  'help', 'support', 'please', 'question',
+  'after', 'before', 'into', 'only', 'then', 'than', 'them', 'they',
+  'use', 'used', 'using',
+]);
+
+// ---------------------------------------------------------------------------
+// tokenize(title) -> string[]
+//
+// Lowercase the title, replace any non-[a-z0-9] run with a space, split on
+// whitespace, drop tokens shorter than MIN_TOKEN_LENGTH, drop STOPWORDS, and
+// dedupe while preserving stable first-occurrence order.
+//
+// Non-string, null, or empty input returns []. Must not throw on any input.
+// ---------------------------------------------------------------------------
+
+function tokenize(title) {
+  if (typeof title !== 'string' || !title) return [];
+
+  const normalized = title.toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+  if (!normalized) return [];
+
+  const seen = new Set();
+  const result = [];
+
+  for (const token of normalized.split(' ')) {
+    if (!token || token.length < MIN_TOKEN_LENGTH) continue;
+    if (STOPWORDS.has(token)) continue;
+    if (seen.has(token)) continue;
+    seen.add(token);
+    result.push(token);
+  }
+
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// diceSimilarity(aTokens, bTokens) -> number 0..1
+//
+// Sørensen–Dice over the token sets: 2 * |A ∩ B| / (|A| + |B|).
+// Both inputs are treated as sets (duplicates ignored). Empty either side -> 0.
+// Identical sets -> 1.
+// ---------------------------------------------------------------------------
+
+function diceSimilarity(aTokens, bTokens) {
+  const setA = new Set(aTokens);
+  const setB = new Set(bTokens);
+
+  if (setA.size === 0 || setB.size === 0) return 0;
+
+  let intersection = 0;
+  for (const token of setA) {
+    if (setB.has(token)) intersection += 1;
+  }
+
+  return (2 * intersection) / (setA.size + setB.size);
+}
+
+// ---------------------------------------------------------------------------
+// scoreCandidates(newTitle, candidates, opts) -> [{number, title, score}]
+//
+// opts: { threshold=DEFAULT_THRESHOLD, limit=DEFAULT_MAX_CANDIDATES, excludeNumber }
+//
+// Tokenizes newTitle once. If no tokens -> []. Filters out null/garbage
+// candidates, those missing a number, and the excluded number. Scores each
+// using diceSimilarity. Keeps score >= threshold. Sorts DESC by score,
+// tie-break ASC by number. Caps to limit.
+// ---------------------------------------------------------------------------
+
+function scoreCandidates(newTitle, candidates, opts) {
+  const threshold = (opts && opts.threshold != null) ? opts.threshold : DEFAULT_THRESHOLD;
+  const limit = (opts && opts.limit != null) ? opts.limit : DEFAULT_MAX_CANDIDATES;
+  const excludeNumber = opts && opts.excludeNumber;
+
+  const newTokens = tokenize(newTitle);
+  if (newTokens.length === 0) return [];
+
+  const scored = [];
+
+  const safeCandidates = Array.isArray(candidates) ? candidates : [];
+  for (const candidate of safeCandidates) {
+    if (!candidate || typeof candidate !== 'object') continue;
+    if (!(typeof candidate.number === 'number' && Number.isFinite(candidate.number))) continue;
+    if (candidate.number === excludeNumber) continue;
+
+    const score = diceSimilarity(newTokens, tokenize(candidate.title));
+    if (score < threshold) continue;
+
+    scored.push({ number: candidate.number, title: candidate.title, score });
+  }
+
+  scored.sort((a, b) => {
+    if (Math.abs(a.score - b.score) > 1e-9) return b.score - a.score;
+    return a.number - b.number;
+  });
+
+  return scored.slice(0, limit);
+}
+
+// ---------------------------------------------------------------------------
+// renderChallengeComment(candidates, opts) -> string
+//
+// opts: { windowHours=DEFAULT_WINDOW_HOURS }
+//
+// Deterministic. Must start with CHALLENGE_MARKER on its own line. Must list
+// each candidate as a line with #<number>, title, and percentage similarity.
+// Must mention windowHours and the 👎 veto.
+// ---------------------------------------------------------------------------
+
+function renderChallengeComment(candidates, opts) {
+  const windowHours = (opts && opts.windowHours != null) ? opts.windowHours : DEFAULT_WINDOW_HOURS;
+
+  const lines = [CHALLENGE_MARKER, ''];
+
+  lines.push('**Possible duplicate detected.** This issue may already be reported:');
+  lines.push('');
+
+  for (const candidate of candidates) {
+    const pct = Math.round(candidate.score * 100);
+    lines.push(`- #${candidate.number} — ${candidate.title} (similarity ${pct}%)`);
+  }
+
+  lines.push('');
+  lines.push(
+    `If this is **not** a duplicate, react with 👎 on this comment to veto and keep the issue open. ` +
+    `If no response is received within ${windowHours} hours, this issue may be closed as a duplicate.`,
+  );
+
+  return lines.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// isChallengeComment(body) -> boolean
+//
+// True iff body is a string containing CHALLENGE_MARKER.
+// ---------------------------------------------------------------------------
+
+function isChallengeComment(body) {
+  if (typeof body !== 'string') return false;
+  return body.includes(CHALLENGE_MARKER);
+}
+
+// ---------------------------------------------------------------------------
+// hasExemptLabel(labels) -> boolean
+//
+// labels may be an array of strings or array of {name}. True if any name is
+// in EXEMPT_LABELS.
+// ---------------------------------------------------------------------------
+
+function hasExemptLabel(labels) {
+  if (!Array.isArray(labels)) return false;
+  const exemptSet = new Set(EXEMPT_LABELS);
+  for (const label of labels) {
+    const name = typeof label === 'string' ? label : (label && label.name);
+    if (name && exemptSet.has(name)) return true;
+  }
+  return false;
+}
+
+// ---------------------------------------------------------------------------
+// toMs(value) -> number
+//
+// Coerce a Date, ISO string, or ms-number to milliseconds since epoch.
+// ---------------------------------------------------------------------------
+
+function toMs(value) {
+  if (value instanceof Date) return value.getTime();
+  if (typeof value === 'string') return new Date(value).getTime();
+  return Number(value);
+}
+
+// ---------------------------------------------------------------------------
+// shouldClose(input) -> {close: boolean, reason: string}
+//
+// input: { now, labels, challengeComment, laterUserComments, windowHours=DEFAULT_WINDOW_HOURS }
+//
+// Decision order (returns first match):
+//   1. hasExemptLabel(labels)          -> {close:false, reason:'exempt-label'}
+//   2. !challengeComment               -> {close:false, reason:'no-challenge-comment'}
+//   3. challengeComment.downvoted      -> {close:false, reason:'vetoed'}
+//   4. laterUserComments > 0           -> {close:false, reason:'reporter-responded'}
+//   5. ageHours < windowHours          -> {close:false, reason:'within-window'}
+//   6. else                            -> {close:true,  reason:'duplicate-no-response'}
+// ---------------------------------------------------------------------------
+
+function shouldClose(input) {
+  const {
+    now,
+    labels = [],
+    challengeComment,
+    laterUserComments = 0,
+  } = input;
+  const windowHours = (input.windowHours != null) ? input.windowHours : DEFAULT_WINDOW_HOURS;
+
+  if (hasExemptLabel(labels)) {
+    return { close: false, reason: 'exempt-label' };
+  }
+
+  if (!challengeComment) {
+    return { close: false, reason: 'no-challenge-comment' };
+  }
+
+  if (challengeComment.downvoted) {
+    return { close: false, reason: 'vetoed' };
+  }
+
+  if (laterUserComments > 0) {
+    return { close: false, reason: 'reporter-responded' };
+  }
+
+  const nowMs = toMs(now);
+  const createdMs = toMs(challengeComment.createdAt);
+
+  if (!Number.isFinite(nowMs) || !Number.isFinite(createdMs)) {
+    return { close: false, reason: 'invalid-timestamp' };
+  }
+
+  const ageHours = (nowMs - createdMs) / 3600000;
+
+  if (ageHours < windowHours) {
+    return { close: false, reason: 'within-window' };
+  }
+
+  return { close: true, reason: 'duplicate-no-response' };
+}
+
+// ---------------------------------------------------------------------------
+// Exports
+// ---------------------------------------------------------------------------
+
+module.exports = {
+  POSSIBLE_DUPLICATE_LABEL,
+  HUMAN_REVIEW_LABEL,
+  CHALLENGE_MARKER,
+  DEFAULT_WINDOW_HOURS,
+  DEFAULT_THRESHOLD,
+  DEFAULT_MAX_CANDIDATES,
+  MIN_TOKEN_LENGTH,
+  EXEMPT_LABELS,
+  STOPWORDS,
+  tokenize,
+  diceSimilarity,
+  scoreCandidates,
+  renderChallengeComment,
+  isChallengeComment,
+  hasExemptLabel,
+  shouldClose,
+};

package/scripts/lint-test-file-count.allowlist.json

@@ -121,6 +121,7 @@
     "install": {
       "files": [
         "bug-410-install-defaults-test-mode-guard.test.cjs",
+        "enh-776-install-gemini-hook-events.test.cjs",
         "install-minimal-hooks.test.cjs",
         "install-path-detection.test.cjs",
         "install-regressions.test.cjs",

package/scripts/release-notes/discord-release-summary.cjs

@@ -0,0 +1,373 @@
+#!/usr/bin/env node
+'use strict';
+
+const cp = require('node:child_process');
+const fs = require('fs');
+const path = require('path');
+const { ExitError, runMain } = require('../lib/cli-exit.cjs');
+const { classifyTitle } = require('./format-github-release-notes.cjs');
+
+const DEFAULT_MAX_CONTENT = 1850;
+const SECTION_LIMITS = Object.freeze([
+  ['Breaking', 4],
+  ['Security', 4],
+  ['Feature', 4],
+  ['Fix', 4],
+  ['Enhancement', 3],
+  ['Internal', 2],
+  ['New Contributors', 3],
+]);
+
+function normalizeNewlines(value) {
+  return String(value || '').replace(/\r\n/g, '\n');
+}
+
+function releaseTag(release) {
+  return release.tagName || release.tag_name || release.name || 'release';
+}
+
+function releaseName(release) {
+  return release.name || releaseTag(release);
+}
+
+function releaseUrl(release) {
+  return release.url || release.html_url || '';
+}
+
+function releaseIsPrerelease(release) {
+  return release.isPrerelease === true || release.prerelease === true || /-/.test(releaseTag(release));
+}
+
+function loadPackageName(repoRoot = path.resolve(__dirname, '..', '..')) {
+  const pkgJson = JSON.parse(fs.readFileSync(path.join(repoRoot, 'package.json'), 'utf8'));
+  return pkgJson.name || 'package';
+}
+
+function normalizeHeading(value) {
+  const heading = value.trim().replace(/:$/, '');
+  const lower = heading.toLowerCase();
+
+  if (lower.includes('breaking')) return 'Breaking';
+  if (lower.includes('security')) return 'Security';
+  if (lower === 'feature' || lower === 'features') return 'Feature';
+  if (lower === 'fix' || lower === 'fixes' || lower === 'bug fixes') return 'Fix';
+  if (lower === 'enhancement' || lower === 'enhancements' || lower === 'improvements') return 'Enhancement';
+  if (lower === 'internal' || lower === 'maintenance') return 'Internal';
+  if (lower === 'new contributors') return 'New Contributors';
+  if (lower === "what's changed" || lower === 'whats changed') return "What's Changed";
+  return heading;
+}
+
+function collectSections(body) {
+  const sections = new Map();
+  let current = null;
+
+  for (const line of normalizeNewlines(body).split('\n')) {
+    const trimmed = line.trim();
+    const heading = trimmed.match(/^#{2,3}\s+(.+)$/);
+
+    if (heading) {
+      current = normalizeHeading(heading[1]);
+      continue;
+    }
+
+    const bullet = trimmed.match(/^([*-])\s+(.+)$/);
+    if (!bullet || !current) continue;
+
+    let section = current;
+    if (section === "What's Changed") {
+      section = classifyTitle(trimmed);
+    }
+
+    if (!sections.has(section)) sections.set(section, []);
+    sections.get(section).push(cleanBullet(trimmed));
+  }
+
+  return sections;
+}
+
+function cleanBullet(value) {
+  let text = String(value)
+    .replace(/^[*-]\s+/, '')
+    .replace(/\s+by\s+@[A-Za-z0-9-]+\s+in\s+https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/(\d+)/g, ' (#$1)')
+    .replace(/\[([^\]]+)\]\((https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/(?:pull|issues)\/(\d+))\)/g, '$1 (#$3)')
+    .replace(/\[([^\]]+)\]\((https?:\/\/[^)]+)\)/g, '$1')
+    .replace(/https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/pull\/(\d+)/g, '#$1')
+    .replace(/https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/issues\/(\d+)/g, '#$1')
+    .replace(/https:\/\/github\.com\/[^/\s]+\/[^/\s]+\/commit\/([0-9a-f]{7})[0-9a-f]*/gi, '$1')
+    .replace(/\*\*/g, '')
+    .replace(/\s+/g, ' ')
+    .trim();
+
+  text = text
+    .replace(/^\[codex\]\s+/i, '')
+    .replace(/^(?:feat|fix|docs|chore|ci|refactor|test)(?:\([^)]+\))?!?:\s+/i, '');
+  text = text.replace(/#(\d+)\s+\(#\1\)/g, '#$1');
+  text = text.replace(/\s+\(#(\d+)\)\s+\(#\1\)$/g, ' (#$1)');
+
+  return truncateAtWord(text, 220);
+}
+
+function truncateAtWord(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  const splitAt = value.lastIndexOf(' ', maxLength - 3);
+  if (splitAt < 80) return `${value.slice(0, maxLength - 3)}...`;
+  return `${value.slice(0, splitAt)}...`;
+}
+
+function extractInstallCommand(body, packageName, release) {
+  const lines = normalizeNewlines(body).split('\n');
+  let inInstall = false;
+  let inFence = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    if (/^##\s+Install\b/i.test(trimmed)) {
+      inInstall = true;
+      continue;
+    }
+
+    if (inInstall && /^##\s+/.test(trimmed)) break;
+    if (!inInstall) continue;
+
+    if (trimmed.startsWith('```')) {
+      inFence = !inFence;
+      continue;
+    }
+
+    if (inFence && /^npm\s+(?:i|install)\s+/.test(trimmed)) {
+      return trimmed;
+    }
+  }
+
+  const channel = releaseIsPrerelease(release) ? 'next' : 'latest';
+  return `npm i ${packageName}@${channel}`;
+}
+
+function buildDiscordReleasePayload({ release, packageName = loadPackageName(), maxContent = DEFAULT_MAX_CONTENT }) {
+  const tag = releaseTag(release);
+  const name = releaseName(release);
+  const url = releaseUrl(release);
+  const prerelease = releaseIsPrerelease(release);
+  const channel = prerelease ? 'next' : 'latest';
+  const body = release.body || '';
+  const sections = collectSections(body);
+  const footer = url ? `Full changelog: ${url}` : `Full changelog: ${tag}`;
+  const baseLines = [
+    `**${packageName} ${name}${prerelease ? ' pre-release' : ''} is out**`,
+    '',
+    'Install:',
+    `\`${extractInstallCommand(body, packageName, release)}\``,
+  ];
+
+  const lines = baseLines.slice();
+  for (const [section, limit] of SECTION_LIMITS) {
+    appendSection(lines, section, sections.get(section) || [], limit, footer, maxContent);
+  }
+
+  if (lines.length === baseLines.length) {
+    appendLineGroup(lines, ['', 'No release notes were provided.'], footer, maxContent);
+  }
+
+  if (joinedLength(lines, footer) > maxContent) {
+    while (lines.length > baseLines.length && joinedLength(lines, footer) > maxContent) {
+      lines.pop();
+    }
+  }
+
+  const content = [...lines, '', footer].join('\n');
+  return {
+    username: 'GSD Releases',
+    content,
+    embeds: [
+      {
+        title: 'Release details',
+        url: url || undefined,
+        color: prerelease ? 0xd9a441 : 0x2f9e44,
+        fields: [
+          { name: 'Package', value: `\`${packageName}\``, inline: true },
+          { name: 'Channel', value: `\`${channel}\``, inline: true },
+          { name: 'Version', value: `\`${tag}\``, inline: true },
+        ],
+      },
+    ],
+    allowed_mentions: { parse: [] },
+  };
+}
+
+function appendSection(lines, section, bullets, limit, footer, maxContent) {
+  if (bullets.length === 0) return;
+
+  const label = sectionLabel(section);
+  const selected = [];
+  for (const bullet of bullets.slice(0, limit)) {
+    const candidate = ['', `**${label}**`, ...selected.map((item) => `- ${item}`), `- ${bullet}`];
+    if (joinedLength([...lines, ...candidate], footer) > maxContent) break;
+    selected.push(bullet);
+  }
+
+  if (selected.length === 0) return;
+
+  const group = ['', `**${label}**`, ...selected.map((item) => `- ${item}`)];
+  const remaining = bullets.length - selected.length;
+  if (remaining > 0) {
+    const moreLine = `- ...and ${remaining} more ${label.toLowerCase()}`;
+    if (joinedLength([...lines, ...group, moreLine], footer) <= maxContent) {
+      group.push(moreLine);
+    }
+  }
+
+  appendLineGroup(lines, group, footer, maxContent);
+}
+
+function appendLineGroup(lines, group, footer, maxContent) {
+  if (joinedLength([...lines, ...group], footer) <= maxContent) {
+    lines.push(...group);
+  }
+}
+
+function joinedLength(lines, footer) {
+  return [...lines, '', footer].join('\n').length;
+}
+
+function sectionLabel(section) {
+  if (section === 'Feature') return 'Features';
+  if (section === 'Fix') return 'Fixes';
+  if (section === 'Enhancement') return 'Enhancements';
+  return section;
+}
+
+function fetchRelease({ tag, repo, latest = false }) {
+  const args = ['release', 'view'];
+  if (!latest && tag) args.push(tag);
+  args.push('--json', 'tagName,name,isPrerelease,body,url');
+  if (repo) args.push('--repo', repo);
+  const raw = cp.execFileSync('gh', args, { encoding: 'utf8' });
+  return JSON.parse(raw);
+}
+
+async function postWebhook(webhookUrl, payload) {
+  const response = await fetch(webhookUrl, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify(payload),
+  });
+
+  if (!response.ok) {
+    throw new ExitError(1, `Discord webhook failed with ${response.status}: ${await response.text()}`);
+  }
+}
+
+function parseArgs(argv) {
+  const opts = {
+    tag: null,
+    repo: null,
+    latest: false,
+    stdin: false,
+    post: false,
+    json: false,
+    allowMissingWebhook: false,
+    packageName: null,
+    maxContent: DEFAULT_MAX_CONTENT,
+  };
+
+  const args = argv.slice();
+  while (args.length > 0) {
+    const arg = args.shift();
+    if (arg === '--tag') {
+      opts.tag = requireValue(args, arg);
+    } else if (arg === '--repo') {
+      opts.repo = requireValue(args, arg);
+    } else if (arg === '--package') {
+      opts.packageName = requireValue(args, arg);
+    } else if (arg === '--max-content') {
+      opts.maxContent = Number(requireValue(args, arg));
+    } else if (arg === '--latest') {
+      opts.latest = true;
+    } else if (arg === '--stdin') {
+      opts.stdin = true;
+    } else if (arg === '--post') {
+      opts.post = true;
+    } else if (arg === '--json') {
+      opts.json = true;
+    } else if (arg === '--allow-missing-webhook') {
+      opts.allowMissingWebhook = true;
+    } else if (arg === '--help' || arg === '-h') {
+      process.stdout.write(
+        'Usage: node scripts/release-notes/discord-release-summary.cjs [--tag <tag>|--latest|--stdin] [options]\n' +
+        '\n' +
+        'Options:\n' +
+        '  --tag <tag>                 GitHub release tag to announce\n' +
+        '  --latest                    Announce the latest GitHub release\n' +
+        '  --stdin                     Read release JSON from stdin\n' +
+        '  --repo <owner/repo>          Repository for gh release view\n' +
+        '  --package <name>             Package name override\n' +
+        '  --post                      POST to DISCORD_WEBHOOK_URL\n' +
+        '  --allow-missing-webhook      Warn and skip instead of failing when posting without a webhook\n' +
+        '  --json                      Print webhook payload JSON instead of content preview\n' +
+        '  --max-content <n>            Max Discord content characters before webhook footer\n'
+      );
+      throw new ExitError(0);
+    } else {
+      throw new ExitError(2, `error: unknown argument ${arg}`);
+    }
+  }
+
+  if (!Number.isFinite(opts.maxContent) || opts.maxContent < 500 || opts.maxContent > 2000) {
+    throw new ExitError(2, 'error: --max-content must be between 500 and 2000');
+  }
+
+  return opts;
+}
+
+function requireValue(args, flag) {
+  const value = args.shift();
+  if (!value || value.startsWith('-')) {
+    throw new ExitError(2, `error: ${flag} requires a value`);
+  }
+  return value;
+}
+
+async function main() {
+  const opts = parseArgs(process.argv.slice(2));
+  let release;
+
+  if (opts.stdin) {
+    release = JSON.parse(fs.readFileSync('/dev/stdin', 'utf8'));
+  } else {
+    release = fetchRelease(opts);
+  }
+
+  const payload = buildDiscordReleasePayload({
+    release,
+    packageName: opts.packageName || loadPackageName(),
+    maxContent: opts.maxContent,
+  });
+
+  if (opts.post) {
+    const webhookUrl = process.env.DISCORD_WEBHOOK_URL;
+    if (!webhookUrl) {
+      if (opts.allowMissingWebhook) {
+        process.stderr.write('warning: DISCORD_WEBHOOK_URL is not set; skipping Discord announcement\n');
+      } else {
+        throw new ExitError(1, 'error: DISCORD_WEBHOOK_URL is not set');
+      }
+    } else {
+      await postWebhook(webhookUrl, payload);
+    }
+  }
+
+  process.stdout.write(opts.json ? `${JSON.stringify(payload, null, 2)}\n` : `${payload.content}\n`);
+}
+
+if (require.main === module) {
+  runMain(main);
+}
+
+module.exports = {
+  buildDiscordReleasePayload,
+  cleanBullet,
+  collectSections,
+  extractInstallCommand,
+};

package/scripts/research-profiles.cjs

@@ -82,7 +82,7 @@ const PROFILES = [
     name: 'gsd-ai-researcher',
     description:
       'Researches a chosen AI framework\'s official docs to produce implementation-ready guidance — best practices, syntax, core patterns, and pitfalls distilled for the specific use case. Writes the Framework Quick Reference and Implementation Guidance sections of AI-SPEC.md. Spawned by /gsd:ai-integration-phase orchestrator.',
-    color: '"#34D399"',
+    color: 'green',
     tools:
       'Read, Write, Edit, Bash, Grep, Glob, WebFetch, WebSearch, mcp__context7__*',
     requiredIncludes: [
@@ -99,7 +99,7 @@ const PROFILES = [
     name: 'gsd-domain-researcher',
     description:
       'Researches the business domain and real-world application context of the AI system being built. Surfaces domain expert evaluation criteria, industry-specific failure modes, regulatory context, and what "good" looks like for practitioners in this field — before the eval-planner turns it into measurable rubrics. Spawned by /gsd:ai-integration-phase orchestrator.',
-    color: '"#A78BFA"',
+    color: 'purple',
     tools:
       'Read, Write, Edit, Bash, Grep, Glob, WebSearch, WebFetch, mcp__context7__*',
     requiredIncludes: [
@@ -115,7 +115,7 @@ const PROFILES = [
     name: 'gsd-ui-researcher',
     description:
       'Produces UI-SPEC.md design contract for frontend phases. Reads upstream artifacts, detects design system state, asks only unanswered questions. Spawned by /gsd:ui-phase orchestrator.',
-    color: '"#E879F9"',
+    color: 'purple',
     tools:
       'Read, Write, Edit, Bash, Grep, Glob, WebSearch, WebFetch, mcp__context7__*, mcp__firecrawl__*, mcp__exa__*, mcp__tavily__*, mcp__ref__*, mcp__jina__*',
     requiredIncludes: [