@polymorphism-tech/morph-spec 4.22.0 → 5.0.1

package/framework/hooks/claude-code/post-tool-use/dispatch.js

@@ -1,363 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * PostToolUse Hook: Dispatch + Validator Injection
- *
- * Event: PostToolUse | Matcher: Bash
- *
- * Handles:
- *   - morph-spec task done: auto-checkpoint every 3 tasks + validator dispatch injection
- *   - morph-spec phase advance: phase chain evaluation + validator dispatch injection
- *   - morph-spec approve: pass-through
- *
- * Validator dispatch: extracts VALIDATION DISPATCH JSON from tool output
- * and injects it as additionalContext so Claude reliably dispatches validators
- * as subagents via the Agent tool.
- *
- * Fail-open: exits 0 on any error.
- */
-
-import { execSync } from 'child_process';
-import { readFileSync, existsSync } from 'fs';
-import { resolve, join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-import { readStdin } from '../../shared/stdin-reader.js';
-import { stateExists, getFeature, getFeaturePhase } from '../../shared/state-reader.js';
-import { pass, injectContext } from '../../shared/hook-response.js';
-import { logHookActivity } from '../../shared/activity-logger.js';
-import { extractValidationDispatch, formatValidatorInstruction, getToolOutput, parseTaskDoneCommand, parsePhaseAdvanceCommand, parseDispatchAgentsCommand } from '../../shared/dispatch-helpers.js';
-
-try {
-  if (!stateExists()) pass();
-
-  const payload = await readStdin();
-  if (!payload) pass();
-
-  const command = payload?.tool_input?.command || '';
-  if (!command) pass();
-
-  await dispatch(command, payload);
-} catch {
-  // Fail-open
-  process.exit(0);
-}
-
-async function dispatch(command, payload) {
-  // morph-spec task done <feature> <taskId> [--skip-validation]
-  const taskDoneParsed = parseTaskDoneCommand(command);
-  if (taskDoneParsed) {
-    const { featureName } = taskDoneParsed;
-    const skipValidation = command.includes('--skip-validation');
-
-    const contextParts = [];
-
-    // Check if checkpoint should run (every 3 tasks)
-    let dispatchResult = 'task_done';
-    try {
-      const feature = getFeature(featureName);
-      if (feature?.tasks) {
-        const completed = (feature.tasks.completed || 0) + 1;
-        if (completed > 0 && completed % 3 === 0) {
-          const checkpointNum = Math.floor(completed / 3);
-          run(`morph-spec checkpoint-save ${featureName} --note "Auto-checkpoint #${checkpointNum} at task ${completed}"`);
-          dispatchResult = 'checkpoint_saved';
-        }
-      }
-    } catch {
-      // Non-blocking
-    }
-
-    // Evaluator dispatch: if sprint contract exists, instruct Claude to dispatch evaluator
-    try {
-      const taskId = taskDoneParsed.taskId;
-      if (taskId && !command.includes('--skip-eval')) {
-        const contractPath = join(process.cwd(), '.morph', 'features', featureName, '5-implement', 'contracts', `${taskId}-contract.yaml`);
-        if (existsSync(contractPath)) {
-          const contractContent = readFileSync(contractPath, 'utf-8');
-          let changedFiles = '';
-          try {
-            changedFiles = execSync('git diff --name-only HEAD~1 2>/dev/null | head -10', {
-              cwd: process.cwd(), encoding: 'utf-8', timeout: 5000, stdio: ['pipe', 'pipe', 'pipe']
-            }).trim();
-          } catch { /* no git */ }
-
-          // Include score context from latest validation if available
-          let scoreContext = '';
-          try {
-            const evalFeature = getFeature(featureName);
-            const taskScores = evalFeature?.validationHistory?.[taskId]?.scores;
-            if (taskScores) {
-              scoreContext = `\n## Previous Validation Score: ${taskScores.score}/10\n` +
-                Object.entries(taskScores.breakdown || {})
-                  .map(([cat, d]) => `  ${cat}: ${Math.round(d.score * 10) / 10}/10 (weight ${Math.round(d.weight * 100)}%)`)
-                  .join('\n') + '\n\nFocus your evaluation on categories with the lowest scores.\n';
-            }
-          } catch { /* non-blocking */ }
-
-          contextParts.push(
-            `🔍 EVALUATOR DISPATCH\n` +
-            `════════════════════════════════════════\n` +
-            `Sprint contract exists for ${taskId}. Dispatch an evaluator sub-agent:\n\n` +
-            `Use the Agent tool with:\n` +
-            `  subagent_type: "general-purpose"\n` +
-            `  model: "sonnet"\n` +
-            `  prompt: (see below)\n\n` +
-            `--- EVALUATOR PROMPT ---\n` +
-            `You are an ADVERSARIAL evaluator. Your default assumption is that defects exist.\n` +
-            `Do NOT confirm correctness — actively search for problems.\n\n` +
-            `## Contract\n${contractContent}\n\n` +
-            `## Changed Files\n${changedFiles || '(unable to determine)'}\n` +
-            `${scoreContext}\n` +
-            `## Instructions\n` +
-            `1. Read each changed file\n` +
-            `2. Run the verification commands from the contract\n` +
-            `3. Evaluate each definitionOfDone item: PASS or FAIL with evidence\n` +
-            `4. For each category, score 0-10 and explain deficiencies found\n` +
-            `5. A clean report is suspicious — dig deeper before declaring PASS\n` +
-            `6. Return a structured result with overall PASS/FAIL and score breakdown\n` +
-            `--- END EVALUATOR PROMPT ---`
-          );
-        }
-      }
-    } catch {
-      // Non-blocking — evaluator is optional
-    }
-
-    // Always inject validator dispatch — deferred if --skip-validation
-    const validatorText = await buildValidatorDispatchContext(featureName, payload);
-    if (validatorText) {
-      if (skipValidation) {
-        // Include budget info when available
-        let budgetInfo = '';
-        try {
-          const feature = getFeature(featureName);
-          if (feature) {
-            const total = feature.tasks?.total || 0;
-            const budget = total === 0 ? 1 : Math.max(1, Math.min(5, Math.ceil(total * 0.2)));
-            const used = (feature.skipValidationLog || []).length;
-            budgetInfo = ` (budget: ${used}/${budget})`;
-          }
-        } catch {
-          // Non-blocking
-        }
-        contextParts.push(
-          `⏩ DEFERRED TO CHECKPOINT — validators skipped on this task${budgetInfo} but MUST run at next checkpoint:\n\n` +
-          validatorText
-        );
-        dispatchResult = 'task_done_deferred_validators';
-      } else {
-        contextParts.push(validatorText);
-        dispatchResult = 'task_done_with_validators';
-      }
-    }
-
-    logHookActivity('phase-dispatch', 'PostToolUse', dispatchResult);
-
-    if (contextParts.length > 0) {
-      injectContext(contextParts.join('\n\n'));
-    }
-    pass();
-  }
-
-  // morph-spec phase advance <feature>
-  const phaseAdvanceParsed = parsePhaseAdvanceCommand(command);
-  if (phaseAdvanceParsed) {
-    const { featureName } = phaseAdvanceParsed;
-
-    const contextParts = [];
-
-    // Phase chain evaluation
-    const chainText = buildPhaseChainContext(featureName);
-    if (chainText) contextParts.push(chainText);
-
-    // Validator dispatch injection
-    const validatorText = await buildValidatorDispatchContext(featureName, payload);
-    if (validatorText) contextParts.push(validatorText);
-
-    // Mandatory dispatch instruction when advancing to implement phase
-    try {
-      const advancedPhase = getFeaturePhase(featureName);
-      if (advancedPhase === 'implement') {
-        contextParts.push(
-          '🔧 MANDATORY AGENT DISPATCH\n' +
-          '════════════════════════════════════════\n' +
-          `Run this command BEFORE starting any task:\n\n` +
-          `  morph-spec dispatch-agents ${featureName} implement\n\n` +
-          `Task start will be BLOCKED until dispatch is recorded.\n` +
-          `Use the dispatch output to determine execution mode (single/subagents/agent-teams).`
-        );
-      }
-    } catch {
-      // Non-blocking
-    }
-
-    logHookActivity('phase-dispatch', 'PostToolUse',
-      validatorText ? 'phase_advance_with_validators' : 'phase_chain');
-
-    if (contextParts.length > 0) {
-      injectContext(contextParts.join('\n\n'));
-    }
-    pass();
-  }
-
-  // morph-spec dispatch-agents <feature> <phase>
-  const dispatchParsed = parseDispatchAgentsCommand(command);
-  if (dispatchParsed) {
-    const { featureName: dispFeature, phase: dispPhase } = dispatchParsed;
-    if (dispPhase === 'implement') {
-      injectContext(
-        `✓ Agent dispatch recorded for '${dispFeature}' (implement phase).\n` +
-        `You may now start tasks with: morph-spec task start ${dispFeature} <taskId>\n` +
-        `Use the dispatch config above to assign tasks to the correct typed agents.`
-      );
-    }
-    logHookActivity('phase-dispatch', 'PostToolUse', 'dispatch_agents_confirmed');
-    pass();
-  }
-
-  // morph-spec approve <feature> <gate>
-  const approveMatch = command.match(/morph-spec\s+approve\s+(\S+)\s+(\S+)/);
-  if (approveMatch) {
-    // Approval handled by CLI — just pass through
-    pass();
-  }
-
-  // No match — exit cleanly
-  pass();
-}
-
-/**
- * Build phase chain context text (returns null if not applicable).
- * Replaces the old evaluatePhaseChain that called injectContext directly.
- *
- * @param {string} featureName
- * @returns {string|null}
- */
-function buildPhaseChainContext(featureName) {
-  try {
-    const feature = getFeature(featureName);
-    if (!feature) return null;
-
-    const workflowId = feature.workflow;
-    if (!workflowId || workflowId === 'auto') return null;
-
-    const configPath = resolve(
-      process.cwd(),
-      `.morph/framework/workflows/configs/${workflowId}.json`
-    );
-    if (!existsSync(configPath)) return null;
-
-    let workflowConfig;
-    try {
-      workflowConfig = JSON.parse(readFileSync(configPath, 'utf8'));
-    } catch {
-      return null;
-    }
-
-    if (!workflowConfig?.phaseChain?.enabled) return null;
-
-    return (
-      `Phase advance complete. Continue the phase chain:\n` +
-      `  morph-spec phase run ${featureName}\n\n` +
-      `The phase runner will check eligibility and auto-advance if all gates pass. ` +
-      `It will pause automatically on blocked tasks, low pass rate, or trust gates.`
-    );
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Extract validator dispatch from tool output and build injection context.
- *
- * Strategy:
- * 1. Try to parse VALIDATION DISPATCH JSON from the tool_result (stdout of phase advance)
- * 2. If not found, fallback to running dispatch-agents CLI in validate mode
- *
- * @param {string} featureName
- * @param {object} payload - PostToolUse hook payload
- * @returns {string|null} - Formatted injection text or null
- */
-async function buildValidatorDispatchContext(featureName, payload) {
-  try {
-    // Strategy 1: Extract from tool output
-    const toolOutput = getToolOutput(payload);
-    const dispatch = extractValidationDispatch(toolOutput);
-    if (dispatch) return formatValidatorInstruction(dispatch);
-
-    // Strategy 2: Direct import of buildDispatchConfig (no subprocess)
-    return await buildDispatchDirect(featureName);
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Fallback: build validator dispatch config via direct import (no subprocess).
- *
- * Attempts to import buildDispatchConfig from the installed package or local
- * framework. Falls back to null on any error (fail-open).
- *
- * @param {string} featureName
- * @returns {Promise<string|null>}
- */
-async function buildDispatchDirect(featureName) {
-  try {
-    const phase = getFeaturePhase(featureName);
-    if (!phase) return null;
-
-    // Try local project path first, then package path
-    let buildDispatchConfig;
-    const localPath = resolve(process.cwd(), 'src/commands/agents/dispatch-agents.js');
-    const pkgPath = resolve(process.cwd(), 'node_modules/@polymorphism-tech/morph-spec/src/commands/agents/dispatch-agents.js');
-
-    if (existsSync(localPath)) {
-      ({ buildDispatchConfig } = await import(`file://${localPath.replace(/\\/g, '/')}`));
-    } else if (existsSync(pkgPath)) {
-      ({ buildDispatchConfig } = await import(`file://${pkgPath.replace(/\\/g, '/')}`));
-    } else {
-      return null;
-    }
-
-    const config = await buildDispatchConfig(process.cwd(), featureName, phase, { mode: 'validate' });
-    const validators = config.agents?.filter(a => a.tier === 4);
-    if (!validators || validators.length === 0) return null;
-
-    const agentsJsonPath = resolve(process.cwd(), 'framework/agents.json');
-    const pkgAgentsPath = resolve(process.cwd(), 'node_modules/@polymorphism-tech/morph-spec/framework/agents.json');
-    const agentsPath = existsSync(agentsJsonPath) ? agentsJsonPath : pkgAgentsPath;
-
-    let allAgents = {};
-    if (existsSync(agentsPath)) {
-      allAgents = JSON.parse(readFileSync(agentsPath, 'utf8')).agents || {};
-    }
-
-    const dispatch = {
-      validators: validators.map(v => {
-        const agentData = allAgents[v.id];
-        return {
-          id: v.id,
-          title: v.title,
-          taskPrompt: v.taskPrompt,
-          severity: agentData?.hook_behavior?.severity || 'error',
-          blocksOnFail: agentData?.hook_behavior?.blocks_on_fail ?? true,
-          checks: agentData?.hook_behavior?.validates || [],
-        };
-      }),
-    };
-
-    return formatValidatorInstruction(dispatch);
-  } catch {
-    return null;
-  }
-}
-
-function run(cmd) {
-  try {
-    execSync(cmd, { stdio: 'pipe', cwd: process.cwd(), timeout: 30000 });
-  } catch {
-    // Non-blocking
-  }
-}

package/framework/hooks/claude-code/post-tool-use/handle-tool-failure.js

@@ -1,78 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * PostToolUseFailure Hook: Log Tool Failures + Rollback Awareness
- *
- * Event: PostToolUseFailure
- *
- * Runs when any tool fails. Appends a structured JSON entry to
- * .morph/logs/tool-failures.log for debugging and pattern analysis.
- *
- * If a critical failure occurs and there are unstaged changes,
- * suggests git stash as a recovery option.
- *
- * Fail-open: exits 0 on any error.
- */
-
-import { appendFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { execSync } from 'child_process';
-import { readStdin } from '../../shared/stdin-reader.js';
-import { stateExists } from '../../shared/state-reader.js';
-import { injectContext } from '../../shared/hook-response.js';
-import { logHookActivity, logEvent } from '../../shared/activity-logger.js';
-
-const CRITICAL_ERROR_PATTERNS = ['ENOENT', 'EPERM', 'EACCES', 'segfault', 'out of memory', 'ENOMEM'];
-
-try {
-  // Only log in morph-spec projects
-  if (!stateExists()) {
-    process.exit(0);
-  }
-
-  const input = await readStdin();
-
-  const logDir = join(process.cwd(), '.morph', 'logs');
-  mkdirSync(logDir, { recursive: true });
-
-  const entry = {
-    timestamp: new Date().toISOString(),
-    tool: input?.tool_name ?? 'unknown',
-    error: input?.error ?? null,
-    input: input?.tool_input ?? null,
-  };
-
-  appendFileSync(join(logDir, 'tool-failures.log'), JSON.stringify(entry) + '\n');
-  logHookActivity('handle-tool-failure', 'PostToolUseFailure', `logged(${entry.tool})`);
-
-  // Rollback awareness: check for unstaged changes after critical failures
-  const errorStr = JSON.stringify(input?.error || '');
-  const isCritical = CRITICAL_ERROR_PATTERNS.some(p => errorStr.includes(p));
-
-  logEvent('tool_failure', { tool: entry.tool, critical: isCritical });
-
-  if (isCritical) {
-    try {
-      const gitStatus = execSync('git status --porcelain', {
-        cwd: process.cwd(),
-        encoding: 'utf-8',
-        timeout: 5000,
-        stdio: ['pipe', 'pipe', 'pipe']
-      }).trim();
-
-      if (gitStatus) {
-        injectContext(
-          `⚠️ [morph-spec] Critical tool failure (${entry.tool}). ` +
-          `Unstaged changes detected:\n${gitStatus.split('\n').slice(0, 5).join('\n')}\n\n` +
-          `Consider: git stash to save current state before retrying.`
-        );
-      }
-    } catch {
-      // git not available or not a git repo — ignore
-    }
-  }
-} catch {
-  // Fail-open: logging is non-critical
-}
-
-process.exit(0);

package/framework/hooks/claude-code/post-tool-use/validator-feedback.js

@@ -1,194 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * PostToolUse Hook: Validator Feedback
- *
- * Event: PostToolUse | Matcher: Bash
- *
- * Fires after `morph-spec task done` completes.
- * Reads validationHistory for the completed task and injects
- * remediation context when validation failed.
- *
- * This closes the Builder-Validator loop:
- *   task done → runValidation → validationHistory → hook injects context
- *   → LLM sees remediation prompt before next step → auto-fix attempt
- *
- * Fail-open: exits 0 on any error.
- */
-
-import { readStdin } from '../../shared/stdin-reader.js';
-import { stateExists, loadState } from '../../shared/state-reader.js';
-import { injectContext, pass } from '../../shared/hook-response.js';
-import { logHookActivity } from '../../shared/activity-logger.js';
-import { parseTaskDoneCommand } from '../../shared/dispatch-helpers.js';
-
-// Standard IDs referenced in remediation messages
-const STANDARD_REFS = {
-  'di': 'dependency injection best practices',
-  'async': 'async/await and CancellationToken patterns',
-  'security': 'security best practices',
-  'packages': 'NuGet package compatibility',
-  'design-system': 'frontend/design-system/naming.md#css-class-conventions',
-};
-
-try {
-  if (!stateExists()) pass();
-
-  const payload = await readStdin();
-  if (!payload) pass();
-
-  const command = payload?.tool_input?.command || '';
-  if (!command) pass();
-
-  const parsed = parseTaskDoneCommand(command);
-  if (!parsed) pass();
-
-  const { featureName, taskId } = parsed;
-
-  // Load state and find validationHistory for this task
-  const state = loadState();
-  if (!state) pass();
-
-  const feature = state?.features?.[featureName];
-  if (!feature) pass();
-
-  const taskHistory = feature.validationHistory?.[taskId];
-  if (!taskHistory) pass();
-
-  // Only act on failed validations (passed = no feedback needed)
-  if (taskHistory.status === 'passed') {
-    logHookActivity('validator-feedback', 'PostToolUse', 'passed');
-    pass();
-  }
-
-  // Build remediation context based on validation issues
-  logHookActivity('validator-feedback', 'PostToolUse', `remediation_injected(attempt_${taskHistory.attempt || 1})`);
-  buildRemediationContext(featureName, taskId, taskHistory);
-} catch {
-  // Fail-open
-  process.exit(0);
-}
-
-/**
- * Build and inject remediation context for a failed validation.
- *
- * @param {string} featureName
- * @param {string} taskId
- * @param {Object} taskHistory - validationHistory[taskId]
- */
-function buildRemediationContext(featureName, taskId, taskHistory) {
-  const attempt = taskHistory.attempt || 1;
-  const validators = taskHistory.validators || {};
-  const scores = taskHistory.scores || null;
-
-  // Collect all issues across all validators
-  const allIssues = [];
-  for (const [validatorName, result] of Object.entries(validators)) {
-    if (result.passed) continue;
-    const issues = result.issues || [];
-    for (const issue of issues) {
-      allIssues.push({ validator: validatorName, ...issue });
-    }
-  }
-
-  if (allIssues.length === 0 && taskHistory.status !== 'blocked') return;
-
-  const lines = [];
-
-  if (taskHistory.status === 'blocked') {
-    // Max attempts reached OR score-based escalation
-    const scoreInfo = scores ? ` (score: ${scores.score}/10)` : '';
-    lines.push(`⛔ ESCALATION REQUIRED — Task ${taskId} in feature '${featureName}'${scoreInfo}`);
-    if (scores?.action === 'escalate') {
-      lines.push(`   Score below retry threshold — immediate escalation.`);
-    } else {
-      lines.push(`   Validation failed ${attempt} times (max attempts reached).`);
-    }
-    lines.push(`   Human review required before proceeding.`);
-    if (scores) {
-      lines.push(``);
-      lines.push(`   Score breakdown:`);
-      appendScoreBreakdown(lines, scores);
-    }
-    lines.push(`   Last failures:`);
-    for (const issue of allIssues.slice(0, 5)) {
-      lines.push(`     • [${issue.validator}] ${issue.message} ${issue.file ? `(${issue.file}${issue.line ? ':' + issue.line : ''})` : ''}`);
-    }
-  } else {
-    // Active remediation — attempt N of 3
-    const scoreInfo = scores ? ` | score: ${scores.score}/10` : '';
-    lines.push(`🔄 REMEDIATION REQUIRED — Task ${taskId} (attempt ${attempt}/3${scoreInfo})`);
-    lines.push(`   Validation failed. Fix the following issues and re-run:`);
-    lines.push(`   morph-spec task done ${featureName} ${taskId}`);
-    lines.push(``);
-
-    // Score-based prioritized feedback (when available)
-    if (scores?.breakdown) {
-      lines.push(`   Priority fixes (by impact):`);
-      const sorted = Object.entries(scores.breakdown)
-        .filter(([, cat]) => (cat.issues?.length || 0) > 0)
-        .sort((a, b) => ((10 - b[1].score) * b[1].weight) - ((10 - a[1].score) * a[1].weight));
-
-      for (const [category, cat] of sorted) {
-        const topIssue = cat.issues[0];
-        const location = topIssue?.file ? ` (${topIssue.file}${topIssue.line ? ':' + topIssue.line : ''})` : '';
-        const msg = topIssue?.message || 'Issues detected';
-        lines.push(`   ${Math.round(cat.score * 10) / 10}/10 [${category}] ${msg}${location}`);
-        if (cat.issues.length > 1) {
-          lines.push(`         ... and ${cat.issues.length - 1} more issue(s)`);
-        }
-      }
-      lines.push(``);
-      appendScoreBreakdown(lines, scores);
-    } else {
-      // Fallback: original issue-by-issue format
-      for (const issue of allIssues) {
-        const refKey = getRefKey(issue.rule || issue.validator);
-        const ref = refKey ? ` — Ref: ${STANDARD_REFS[refKey] || refKey}` : '';
-        const location = issue.file
-          ? ` (${issue.file}${issue.line ? ':' + issue.line : ''})`
-          : '';
-        lines.push(`  • [${issue.validator}] ${issue.message}${location}${ref}`);
-      }
-    }
-
-    if (attempt >= 2) {
-      lines.push(``);
-      lines.push(`  ⚠️  If this fails again, it will be escalated (attempt ${attempt + 1} = final).`);
-    }
-  }
-
-  injectContext(lines.join('\n'));
-}
-
-/**
- * Append score breakdown lines to output.
- * @param {string[]} lines - Output array
- * @param {Object} scores - { score, action, breakdown }
- */
-function appendScoreBreakdown(lines, scores) {
-  if (!scores?.breakdown) return;
-  const approveThreshold = scores.approveThreshold ?? 8.0;
-  for (const [category, data] of Object.entries(scores.breakdown)) {
-    if (category === '_unmapped') continue; // skip internal unmapped category
-    const pct = Math.round(data.weight * 100);
-    const indicator = data.score >= approveThreshold ? '\u2713' : data.score >= 6 ? '\u2193' : '\u2193\u2193';
-    lines.push(`     ${category}: ${Math.round(data.score * 10) / 10}/10 (weight ${pct}%) ${indicator}`);
-  }
-}
-
-/**
- * Map a rule/validator name to a STANDARD_REFS key.
- * @param {string} ruleOrValidator
- * @returns {string|null}
- */
-function getRefKey(ruleOrValidator) {
-  if (!ruleOrValidator) return null;
-  const lower = ruleOrValidator.toLowerCase();
-  if (lower.includes('di') || lower.includes('dependency') || lower.includes('injection')) return 'di';
-  if (lower.includes('async') || lower.includes('await') || lower.includes('cancellation')) return 'async';
-  if (lower.includes('security') || lower.includes('sql') || lower.includes('xss')) return 'security';
-  if (lower.includes('package') || lower.includes('nuget')) return 'packages';
-  if (lower.includes('design') || lower.includes('css') || lower.includes('naming')) return 'design-system';
-  return null;
-}