@chemx/starter-kit 26.9.12-93 → 26.9.13-272

package/cli/build/parser-matchers.js

@@ -0,0 +1,116 @@
+const TS_PATTERN_PARENS = /^([^(]+)\((\d+),(\d+)\):\s*(error|warning)\s*(TS\d+):\s*(.+)$/;
+const TS_PATTERN_COLONS = /^([^:]+):(\d+):(\d+)\s*-\s*(error|warning)\s*(TS\d+):\s*(.+)$/;
+const ROLLUP_RESOLVE_PATTERN = /Could not resolve ["']([^"']+)["'] from ["']([^"']+)["']/;
+const VITE_ERROR_PATTERN = /\[(vite|rollup|plugin:[^\]]+)\]\s*(.+)/;
+const MODULE_NOT_FOUND_PATTERN = /Module not found:\s*Can['’]t resolve ['"]([^'"]+)['"] in ['"]([^'"]+)['"]/;
+const SASS_POSTCSS_PATTERN = /(CssSyntaxError|SassError):\s*(.+)/;
+
+const resolveTsSuggestion = (code) => {
+  if (code === 'TS2304' || code === 'TS2552') {
+    return 'Ensure the identifier is imported or declared in scope.';
+  }
+  if (code === 'TS2307') {
+    return 'Verify package installation or check tsconfig path aliases.';
+  }
+  if (code === 'TS2322' || code === 'TS2345') {
+    return 'Check property types or update interface declarations.';
+  }
+  if (code === 'TS2339') {
+    return 'Verify property naming or extend type definition.';
+  }
+  return 'Review TypeScript compiler diagnostic.';
+};
+
+export const matchTypeScriptError = (line) => {
+  const parensMatch = line.match(TS_PATTERN_PARENS);
+  if (parensMatch) {
+    const [, file, lineNum, colNum, severityStr, code, message] = parensMatch;
+    const severity = severityStr.toLowerCase() === 'warning' ? 'WARNING' : 'ERROR';
+    return {
+      category: 'TYPE_ERROR',
+      severity,
+      file: file.trim(),
+      line: parseInt(lineNum, 10),
+      column: parseInt(colNum, 10),
+      code,
+      message: message.trim(),
+      suggestion: resolveTsSuggestion(code)
+    };
+  }
+
+  const colonsMatch = line.match(TS_PATTERN_COLONS);
+  if (colonsMatch) {
+    const [, file, lineNum, colNum, severityStr, code, message] = colonsMatch;
+    const severity = severityStr.toLowerCase() === 'warning' ? 'WARNING' : 'ERROR';
+    return {
+      category: 'TYPE_ERROR',
+      severity,
+      file: file.trim(),
+      line: parseInt(lineNum, 10),
+      column: parseInt(colNum, 10),
+      code,
+      message: message.trim(),
+      suggestion: resolveTsSuggestion(code)
+    };
+  }
+
+  return null;
+};
+
+export const matchResolveError = (line) => {
+  const rollupMatch = line.match(ROLLUP_RESOLVE_PATTERN);
+  if (rollupMatch) {
+    const [, moduleName, importer] = rollupMatch;
+    return {
+      category: 'RESOLVE_ERROR',
+      severity: 'ERROR',
+      file: importer.trim(),
+      code: 'MODULE_NOT_FOUND',
+      message: `Could not resolve module "${moduleName}"`,
+      suggestion: 'Verify import path alias, file extension, or run package install.'
+    };
+  }
+
+  const moduleMatch = line.match(MODULE_NOT_FOUND_PATTERN);
+  if (moduleMatch) {
+    const [, moduleName, importer] = moduleMatch;
+    return {
+      category: 'RESOLVE_ERROR',
+      severity: 'ERROR',
+      file: importer.trim(),
+      code: 'MODULE_NOT_FOUND',
+      message: `Can't resolve "${moduleName}"`,
+      suggestion: 'Verify dependency is listed in package.json and installed.'
+    };
+  }
+
+  return null;
+};
+
+export const matchBundlerOrStyleError = (line) => {
+  const sassMatch = line.match(SASS_POSTCSS_PATTERN);
+  if (sassMatch) {
+    const [, errorType, message] = sassMatch;
+    return {
+      category: 'STYLE_ERROR',
+      severity: 'ERROR',
+      code: errorType,
+      message: message.trim(),
+      suggestion: 'Check stylesheet syntax, missing variable, or mixin import.'
+    };
+  }
+
+  const viteMatch = line.match(VITE_ERROR_PATTERN);
+  if (viteMatch) {
+    const [, plugin, message] = viteMatch;
+    return {
+      category: 'SYNTAX_ERROR',
+      severity: 'ERROR',
+      code: plugin,
+      message: message.trim(),
+      suggestion: 'Check component template syntax or plugin configuration.'
+    };
+  }
+
+  return null;
+};

package/cli/build/parser.js

@@ -0,0 +1,80 @@
+import { stripAnsi } from '../terminal.js';
+import {
+  matchTypeScriptError,
+  matchResolveError,
+  matchBundlerOrStyleError
+} from './parser-matchers.js';
+
+const CHUNK_BUDGET_PATTERN = /chunks are larger than \d+\s*kBs/i;
+const GENERIC_ERROR_PATTERN = /^(SyntaxError|ReferenceError|TypeError|Error):\s*(.+)$/;
+
+const cleanAnsiText = (text) => {
+  return stripAnsi(text).replace(/\u001b\[[0-9;]*[a-zA-Z]/g, '');
+};
+
+const matchBudgetWarning = (line) => {
+  const isBudgetIssue = CHUNK_BUDGET_PATTERN.test(line);
+  if (!isBudgetIssue) return null;
+  return {
+    category: 'BUDGET_WARNING',
+    severity: 'WARNING',
+    code: 'CHUNK_OVER_BUDGET',
+    message: line.trim(),
+    suggestion: 'Use dynamic imports or configure build.rollupOptions.output.manualChunks.'
+  };
+};
+
+const matchGenericError = (line) => {
+  const match = line.match(GENERIC_ERROR_PATTERN);
+  if (!match) return null;
+  const [, code, message] = match;
+  return {
+    category: 'RUNTIME_ERROR',
+    severity: 'ERROR',
+    code,
+    message: message.trim(),
+    suggestion: 'Inspect stack trace or surrounding code for unhandled exceptions.'
+  };
+};
+
+export const parseBuildOutput = (stdout, stderr) => {
+  const combined = `${stdout}\n${stderr}`;
+  const lines = combined.split(/\r?\n/);
+  const diagnostics = [];
+
+  for (const rawLine of lines) {
+    const cleanLine = cleanAnsiText(rawLine).trim();
+    if (!cleanLine) continue;
+
+    const tsDiagnostic = matchTypeScriptError(cleanLine);
+    if (tsDiagnostic) {
+      diagnostics.push({ ...tsDiagnostic, rawSnippet: cleanLine });
+      continue;
+    }
+
+    const resolveDiagnostic = matchResolveError(cleanLine);
+    if (resolveDiagnostic) {
+      diagnostics.push({ ...resolveDiagnostic, rawSnippet: cleanLine });
+      continue;
+    }
+
+    const bundlerDiagnostic = matchBundlerOrStyleError(cleanLine);
+    if (bundlerDiagnostic) {
+      diagnostics.push({ ...bundlerDiagnostic, rawSnippet: cleanLine });
+      continue;
+    }
+
+    const budgetDiagnostic = matchBudgetWarning(cleanLine);
+    if (budgetDiagnostic) {
+      diagnostics.push({ ...budgetDiagnostic, rawSnippet: cleanLine });
+      continue;
+    }
+
+    const genericDiagnostic = matchGenericError(cleanLine);
+    if (genericDiagnostic) {
+      diagnostics.push({ ...genericDiagnostic, rawSnippet: cleanLine });
+    }
+  }
+
+  return diagnostics;
+};

package/cli/build/reporter.js

@@ -0,0 +1,66 @@
+import { ANSI } from '../theme.js';
+
+const formatDiagnosticItem = (item) => {
+  const loc = item.file
+    ? `${ANSI.CYAN}${item.file}${item.line ? `:${item.line}` : ''}${item.column ? `:${item.column}` : ''}${ANSI.RESET}`
+    : `${ANSI.DIM}unknown location${ANSI.RESET}`;
+  const codeTag = item.code ? ` ${ANSI.DIM}[${item.code}]${ANSI.RESET}` : '';
+  const hint = item.suggestion ? `\n    ${ANSI.MINT}↳ Hint: ${item.suggestion}${ANSI.RESET}` : '';
+  return `  • ${loc}${codeTag} ${item.message}${hint}`;
+};
+
+const formatCategoryGroup = (category, items) => {
+  const title = `${ANSI.BOLD}${ANSI.PINK}[${category}]${ANSI.RESET} ${ANSI.DIM}(${items.length})${ANSI.RESET}`;
+  const lines = items.map(formatDiagnosticItem);
+  return `${title}\n${lines.join('\n')}`;
+};
+
+export const formatTerminalBuildReport = (report, options = {}) => {
+  const isSilent = Boolean(options.silent);
+  const durationSec = (report.durationMs / 1000).toFixed(2);
+
+  if (report.success) {
+    if (isSilent) return '';
+    const successHeader = `${ANSI.BOLD}${ANSI.LIME}✔ Build Succeeded${ANSI.RESET} ${ANSI.DIM}(${durationSec}s)${ANSI.RESET}`;
+    if (report.counts.warnings === 0) return `${successHeader}\n`;
+
+    const warningLines = report.diagnostics
+      .filter((d) => d.severity === 'WARNING')
+      .map(formatDiagnosticItem)
+      .join('\n');
+    return `${successHeader}\n${ANSI.GOLD}Warnings (${report.counts.warnings}):${ANSI.RESET}\n${warningLines}\n`;
+  }
+
+  const out = [];
+  out.push(`${ANSI.BOLD}\x1b[31m✕ Build Failed${ANSI.RESET} ${ANSI.DIM}(exit code ${report.exitCode}, ${durationSec}s)${ANSI.RESET}`);
+  out.push(`${ANSI.DIM}Command: ${report.command}${ANSI.RESET}\n`);
+
+  if (report.diagnostics.length > 0) {
+    const grouped = {};
+    for (const d of report.diagnostics) {
+      if (!grouped[d.category]) grouped[d.category] = [];
+      grouped[d.category].push(d);
+    }
+    for (const [cat, items] of Object.entries(grouped)) {
+      out.push(formatCategoryGroup(cat, items));
+      out.push('');
+    }
+  } else if (report.rawTail.length > 0) {
+    out.push(`${ANSI.BOLD}${ANSI.GOLD}[UNCATALOGED BUILD OUTPUT]${ANSI.RESET}`);
+    for (const line of report.rawTail) {
+      out.push(`  ${ANSI.DIM}${line}${ANSI.RESET}`);
+    }
+    out.push('');
+  }
+
+  out.push(
+    `${ANSI.BOLD}Audit Summary:${ANSI.RESET} ${report.counts.errors} error(s), ${report.counts.warnings} warning(s) across ${report.counts.files} file(s).`
+  );
+  out.push(`${ANSI.DIM}Tip: Run with --json to emit structured machine-readable diagnostics for AI agents.${ANSI.RESET}\n`);
+
+  return out.join('\n');
+};
+
+export const formatJsonBuildReport = (report) => {
+  return JSON.stringify(report, null, 2);
+};

package/cli/build/types.d.ts

@@ -0,0 +1,58 @@
+export type BuildDiagnosticCategory =
+  | 'TYPE_ERROR'
+  | 'RESOLVE_ERROR'
+  | 'SYNTAX_ERROR'
+  | 'STYLE_ERROR'
+  | 'BUDGET_WARNING'
+  | 'COMPILER_WARNING'
+  | 'RUNTIME_ERROR'
+  | 'UNKNOWN';
+
+export type BuildDiagnosticSeverity = 'ERROR' | 'WARNING' | 'INFO';
+
+export interface BuildDiagnostic {
+  readonly category: BuildDiagnosticCategory;
+  readonly severity: BuildDiagnosticSeverity;
+  readonly file?: string;
+  readonly line?: number;
+  readonly column?: number;
+  readonly code?: string;
+  readonly message: string;
+  readonly suggestion?: string;
+  readonly rawSnippet?: string;
+}
+
+export interface BuildSummaryCounts {
+  readonly total: number;
+  readonly errors: number;
+  readonly warnings: number;
+  readonly files: number;
+}
+
+export interface BuildAuditReport {
+  readonly success: boolean;
+  readonly exitCode: number;
+  readonly durationMs: number;
+  readonly command: string;
+  readonly counts: BuildSummaryCounts;
+  readonly categories: Record<string, number>;
+  readonly diagnostics: readonly BuildDiagnostic[];
+  readonly rawTail: readonly string[];
+}
+
+export interface BuildOptions {
+  readonly command?: string;
+  readonly silent?: boolean;
+  readonly json?: boolean;
+  readonly summary?: boolean;
+  readonly raw?: boolean;
+  readonly cwd?: string;
+}
+
+export interface BuildExecutionResult {
+  readonly exitCode: number;
+  readonly stdout: string;
+  readonly stderr: string;
+  readonly durationMs: number;
+  readonly command: string;
+}

package/cli/build/types.js

@@ -0,0 +1 @@
+export {};

package/cli/build.d.ts

@@ -0,0 +1,16 @@
+import type { BuildAuditReport, BuildOptions } from './build/types.js';
+
+export function runBuildAudit(
+  rawArgs?: readonly string[],
+  isCli?: boolean
+): Promise<BuildAuditReport>;
+
+export {
+  BuildDiagnostic,
+  BuildDiagnosticCategory,
+  BuildDiagnosticSeverity,
+  BuildSummaryCounts,
+  BuildAuditReport,
+  BuildOptions,
+  BuildExecutionResult
+} from './build/types.js';

package/cli/build.js

@@ -0,0 +1,55 @@
+import { detectProjectBuildCommand } from './build/detector.js';
+import { executeBuild } from './build/executor.js';
+import { parseBuildOutput } from './build/parser.js';
+import { groupBuildDiagnostics } from './build/grouper.js';
+import { formatTerminalBuildReport, formatJsonBuildReport } from './build/reporter.js';
+import { ANSI } from './theme.js';
+
+const parseCommandFromArgs = (args) => {
+  const dashDashIndex = args.indexOf('--');
+  if (dashDashIndex !== -1) {
+    const afterDash = args.slice(dashDashIndex + 1).join(' ').trim();
+    if (afterDash.length > 0) return afterDash;
+  }
+
+  const candidate = args.find((a) => !a.startsWith('-') && a !== 'build' && a !== 'run' && a !== 'wrap');
+  return candidate ? candidate.trim() : null;
+};
+
+export const runBuildAudit = async (rawArgs = [], isCli = false) => {
+  const isJson = rawArgs.includes('--json');
+  const isSilent = rawArgs.includes('--silent');
+  const isRaw = rawArgs.includes('--raw');
+  const isSummary = rawArgs.includes('--summary');
+
+  const customCommand = parseCommandFromArgs(rawArgs);
+  const command = detectProjectBuildCommand(customCommand, process.cwd());
+
+  const shouldPrintStart = !isJson && !isSilent && !isRaw;
+  if (shouldPrintStart) {
+    process.stdout.write(`${ANSI.CYAN}Auditing build:${ANSI.RESET} ${ANSI.DIM}${command}${ANSI.RESET}\n`);
+  }
+
+  const executionResult = await executeBuild(command, process.cwd(), { raw: isRaw });
+  const rawDiagnostics = parseBuildOutput(executionResult.stdout, executionResult.stderr);
+  const report = groupBuildDiagnostics(rawDiagnostics, executionResult);
+
+  if (isJson) {
+    process.stdout.write(formatJsonBuildReport(report) + '\n');
+    if (isCli) process.exit(report.exitCode);
+    return report;
+  }
+
+  const terminalOutput = formatTerminalBuildReport(report, { silent: isSilent, summary: isSummary });
+  if (terminalOutput) {
+    process.stdout.write(terminalOutput);
+  }
+
+  if (isCli) {
+    process.exit(report.exitCode);
+  }
+
+  return report;
+};
+
+export * from './build/types.js';

package/cli/help.js

@@ -16,6 +16,14 @@ export const printHelp = () => {
     `  ${CYAN}npm create chemx${RESET} [directory]`,
     '',
     `${BOLD}COMMANDS${RESET}`,
+    `  ${CYAN}build${RESET} [options] [-- <command>]  ${DIM}(aliases: run, wrap)${RESET}`,
+    `      Wrap and audit arbitrary build scripts with token-conserving silent execution.`,
+    `      Suppresses multi-thousand-line compiler noise, catalogs diagnostics into`,
+    `      grouped categories (TypeScript, Vite/Rollup, Style, Budget), and provides`,
+    `      actionable remediation hints and machine-readable JSON for AI agents.`,
+    `      Flags: ${CYAN}--json${RESET}, ${CYAN}--silent${RESET}, ${CYAN}--raw${RESET}, ${CYAN}--summary${RESET}`,
+    `      Examples: ${CYAN}npx chemx build${RESET} or ${CYAN}npx chemx build -- pnpm build${RESET}`,
+    '',
     `  ${CYAN}audit${RESET} [options]`,
     `      Run the 7-Pillar Molecular Architecture static analysis audit.`,
     `      Scans AST for line budgets, control flow booleans, nested ternaries,`,
@@ -139,6 +147,12 @@ export const printHelp = () => {
     '',
     `  ${DIM}# Scaffold a new project:${RESET}`,
     `  ${CYAN}npm create chemx my-awesome-app${RESET}`,
+    '',
+    `  ${DIM}# Run token-conserving silent build audit with structured diagnostics:${RESET}`,
+    `  ${CYAN}npx chemx build --silent${RESET}`,
+    '',
+    `  ${DIM}# Wrap arbitrary build command and output AI-ready JSON:${RESET}`,
+    `  ${CYAN}npx chemx build --json -- pnpm run build${RESET}`,
     ''
   ].join('\n');
 

package/cli/index.js

@@ -9,7 +9,8 @@ import {
   generateMarkdownReport,
   saveAuditSnapshot,
   copyToClipboard,
-  buildMasterPrompt
+  buildMasterPrompt,
+  groupViolationsBySeverity
 } from './audit.js';
 import {
   runScaffold,
@@ -23,8 +24,15 @@ import {
   showConversionMenu,
   handleShareToDiscussions
 } from './navigator.js';
+import { renderDashboardBanner } from './navigator-banner.js';
+import {
+  isGradeBelowMinimum,
+  evaluateAuditFailure,
+  isNonInteractiveSession
+} from './audit/rules-predicates.js';
 import { runInstallWizard } from './installer.js';
 import { runBadgeCommand } from './badge.js';
+import { runBuildAudit } from './build.js';
 
 const rawArgs = process.argv.slice(2);
 const invokedBin = path.basename(process.argv[1] || '');
@@ -79,12 +87,11 @@ export const runAudit = async (customDir = null, isCli = false) => {
   const report = executeAstAudit(targetDir, { outputFile, model, costPerMillion });
   saveAuditSnapshot(report);
 
-  const GRADE_RANKS = { 'A+': 5, 'A': 4, 'B': 3, 'C': 2, 'D': 1, 'F': 0 };
   const hasCriticalOrHigh = report.violations.some((v) => v.severity === 'CRITICAL' || v.severity === 'HIGH');
   const isStrictFail = isStrict && report.violations.length > 0;
-  const isGradeFail = Boolean(minGrade && GRADE_RANKS[report.health.grade] !== undefined && GRADE_RANKS[minGrade] !== undefined && GRADE_RANKS[report.health.grade] < GRADE_RANKS[minGrade]);
+  const isGradeFail = isGradeBelowMinimum(report.health.grade, minGrade);
   const isScoreFail = minScore !== null && !isNaN(minScore) && report.health.score < minScore;
-  const hasFailingViolations = isStrictFail || hasCriticalOrHigh || isGradeFail || isScoreFail;
+  const hasFailingViolations = evaluateAuditFailure([isStrictFail, hasCriticalOrHigh, isGradeFail, isScoreFail]);
 
   if (isJson) {
     process.stdout.write(JSON.stringify(report, null, 2) + '\n');
@@ -92,24 +99,21 @@ export const runAudit = async (customDir = null, isCli = false) => {
     return report;
   }
 
-  if (isMarkdown) {
+  if (isMarkdown && !outputFile) {
     const md = generateMarkdownReport(report);
     process.stdout.write(md + '\n');
     if (isCli) process.exit(hasFailingViolations ? 1 : 0);
     return report;
   }
 
-  if (outputFile) {
-    process.stdout.write(`\x1b[32m✔ Exported markdown audit report to:\x1b[0m ${outputFile}\n\n`);
-  }
-
   if (isCli) {
     if (isShare) {
       await handleShareToDiscussions(report);
       process.exit(0);
     }
 
-    const isInteractive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const isNonInteractive = isNonInteractiveSession(rawArgs);
+    const isInteractive = !isNonInteractive && Boolean(process.stdin.isTTY && process.stdout.isTTY);
 
     if (isInteractive && !isUnroll) {
       const handleReAudit = () => {
@@ -123,9 +127,25 @@ export const runAudit = async (customDir = null, isCli = false) => {
         handleReAudit
       );
     } else {
-      process.stdout.write(formatTerminalReport(report));
-      if (isInteractive && isUnroll) {
-        await showConversionMenu(() => runScaffold(undefined, rawArgs, runAudit));
+      if (isUnroll) {
+        process.stdout.write(formatTerminalReport(report));
+        if (isInteractive) {
+          await showConversionMenu(() => runScaffold(undefined, rawArgs, runAudit));
+        }
+      } else {
+        const { critical, high, medium, low } = groupViolationsBySeverity(report.violations);
+        const highMediumCount = high.length + medium.length;
+        renderDashboardBanner(
+          report.health,
+          report.metrics,
+          report.violations,
+          critical,
+          highMediumCount,
+          low,
+          report.contextAnalysis,
+          report.aiSlop,
+          { clear: false }
+        );
       }
     }
 
@@ -145,7 +165,7 @@ export const runAudit = async (customDir = null, isCli = false) => {
   return report;
 };
 
-export { auditFile };
+export { auditFile, runBuildAudit };
 
 const main = async () => {
   const firstArg = rawArgs[0];
@@ -157,6 +177,11 @@ const main = async () => {
   }
 
   switch (firstArg) {
+    case 'build':
+    case 'run':
+    case 'wrap':
+      await runBuildAudit(rawArgs.slice(1), true);
+      break;
     case 'audit':
       await runAudit(null, true);
       break;

package/cli/installer-templates.js

@@ -44,7 +44,7 @@ fi
 
 if [ -n "\$AUDIT_BIN" ]; then
   printf "\\033[38;2;98;201;255m[Chemical X] Verifying architectural health (Min Grade: %s, Min Score: %s)...\\033[0m\\n" "\$MIN_GRADE" "\$MIN_SCORE"
-  if ! \$AUDIT_BIN audit --min-grade="\$MIN_GRADE" --min-score="\$MIN_SCORE" --prompt-on-fail; then
+  if ! \$AUDIT_BIN audit --min-grade="\$MIN_GRADE" --min-score="\$MIN_SCORE" --non-interactive < /dev/null; then
     printf "\\n\\033[1m\\033[31m[Chemical X] Commit Blocked: Codebase falls below required Grade %s (Score %s)\\033[0m\\n" "\$MIN_GRADE" "\$MIN_SCORE"
     printf "\\033[36m💡 Tip: Want crystalline drop-in templates? Run 'npm create chemx' or sponsor at https://github.com/sponsors/Chemical-X-Protocol\\033[0m\\n\\n"
     exit 1
@@ -78,14 +78,53 @@ jobs:
       - name: Setup Node.js
         uses: actions/setup-node@v4
         with:
-          node-version: 20
-          cache: npm
+          node-version: 22
+
+      - name: Install dependencies
+        run: |
+          if [ -f package-lock.json ]; then
+            npm ci
+          elif [ -f package.json ]; then
+            npm install
+          fi
+
       - name: Run Chemical X Architectural Audit
-        run: npx chemx audit --min-grade=\${{ vars.CHEMX_MIN_GRADE || '${minGrade}' }} --min-score=\${{ vars.CHEMX_MIN_SCORE || ${minScore} }} --markdown --output=AUDIT_REPORT.md
+        run: npx --yes chemx audit --min-grade=\${{ vars.CHEMX_MIN_GRADE || '${minGrade}' }} --min-score=\${{ vars.CHEMX_MIN_SCORE || ${minScore} }} --markdown --output=AUDIT_REPORT.md
       - name: Upload Audit Scorecard Artifact
         if: always()
         uses: actions/upload-artifact@v4
         with:
           name: chemical-x-audit-report
           path: AUDIT_REPORT.md
+
+      - name: Post Architectural Audit Comment on PR
+        if: always() && github.event_name == 'pull_request' && hashFiles('AUDIT_REPORT.md') != ''
+        continue-on-error: true
+        env:
+          GH_TOKEN: \${{ secrets.GITHUB_TOKEN }}
+          PR_NUMBER: \${{ github.event.pull_request.number }}
+          REPO: \${{ github.repository }}
+        run: |
+          DISCUSSION_URL="\${{ vars.CHEMX_DISCUSSION_URL }}"
+          if [ -z "\$DISCUSSION_URL" ] && [ -f .chemx/discussion.json ]; then
+            DISCUSSION_URL=\$(node -e "try { const d = JSON.parse(require('fs').readFileSync('.chemx/discussion.json')); console.log(d.url || ''); } catch (e) {}")
+          fi
+          if [ -z "\$DISCUSSION_URL" ]; then
+            DISCUSSION_URL="https://github.com/orgs/Chemical-X-Protocol/discussions/categories/npx-chemx-audit"
+          fi
+
+          {
+            echo "<!-- chemical-x-audit-pr-comment -->"
+            echo "> 💬 **Architectural Discussion Topic:** [View Discussion & Community Showcase](\$DISCUSSION_URL)"
+            echo ""
+            cat AUDIT_REPORT.md
+          } > PR_COMMENT.md
+
+          EXISTING_COMMENT_ID=\$(gh api "repos/\$REPO/issues/\$PR_NUMBER/comments" --jq '.[] | select(.body | contains("<!-- chemical-x-audit-pr-comment -->")) | .id' | head -n 1)
+
+          if [ -n "\$EXISTING_COMMENT_ID" ]; then
+            gh api --method PATCH "repos/\$REPO/issues/comments/\$EXISTING_COMMENT_ID" -F body=@PR_COMMENT.md
+          else
+            gh pr comment "\$PR_NUMBER" --body-file PR_COMMENT.md
+          fi
 `;

package/cli/license.js

@@ -9,6 +9,7 @@ import {
   promptQuestion,
   openBrowser
 } from './terminal.js';
+import { toResultSync } from './audit/rules-helpers.js';
 
 export const CONFIG_DIR = path.join(os.homedir(), '.chemical-x');
 export const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
@@ -20,14 +21,14 @@ export const URL_SPONSOR = 'https://github.com/sponsors/Chemical-X-Protocol';
 export const URL_STANDARD = 'https://mycompassconsulting.com/buy/chemical-x/standard';
 export const URL_MASTER = 'https://mycompassconsulting.com/buy/chemical-x/master';
 
-if (!fs.existsSync(CONFIG_DIR)) {
-  try {
-    fs.mkdirSync(CONFIG_DIR, { recursive: true });
-  } catch (err) {
-    const error = err instanceof Error ? err : new Error(String(err));
-    process.stderr.write(`Failed to create config directory: ${error.message}\n`);
+export const ensureConfigDir = () => {
+  if (fs.existsSync(CONFIG_DIR)) return true;
+  const [, err] = toResultSync(() => fs.mkdirSync(CONFIG_DIR, { recursive: true }));
+  if (err) {
+    return false;
   }
-}
+  return true;
+};
 
 export const getOrCreateDeviceId = () => {
   if (fs.existsSync(DEVICE_FILE)) {
@@ -40,6 +41,7 @@ export const getOrCreateDeviceId = () => {
     }
   }
   const newId = `cli_${Math.random().toString(36).substring(2, 12)}_${Date.now()}`;
+  ensureConfigDir();
   try {
     fs.writeFileSync(DEVICE_FILE, newId, 'utf-8');
   } catch (err) {
@@ -62,6 +64,7 @@ export const getCachedLicenseKey = () => {
 };
 
 export const saveLicenseKey = (licenseKey) => {
+  ensureConfigDir();
   try {
     fs.writeFileSync(
       CONFIG_FILE,