@polymorphism-tech/morph-spec 4.18.0 → 4.19.0

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

@@ -1,44 +1,78 @@
-#!/usr/bin/env node
-
-/**
- * PostToolUseFailure Hook: Log Tool Failures
- *
- * Event: PostToolUseFailure
- *
- * Runs when any tool fails. Appends a structured JSON entry to
- * .morph/logs/tool-failures.log for debugging and pattern analysis.
- *
- * Fail-open: exits 0 on any error.
- */
-
-import { appendFileSync, mkdirSync } from 'fs';
-import { join } from 'path';
-import { readStdin } from '../../shared/stdin-reader.js';
-import { stateExists } from '../../shared/state-reader.js';
-import { logHookActivity } from '../../shared/activity-logger.js';
-
-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})`);
-} catch {
-  // Fail-open: logging is non-critical
-}
-
-process.exit(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/loop-detect.js

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+/**
+ * PostToolUse Hook: Loop Detection
+ *
+ * Event: PostToolUse | Matcher: none (all tools)
+ *
+ * Detects when an agent is stuck in a repetitive loop by tracking
+ * the last 15 actions. If the last 8 actions have <= 2 unique
+ * signatures, injects a warning with escape instructions.
+ *
+ * Cooldown: 5 minutes between warnings to prevent meta-loop.
+ *
+ * Fail-open: exits 0 on any error.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { join } from 'path';
+import { readStdin } from '../../shared/stdin-reader.js';
+import { stateExists } from '../../shared/state-reader.js';
+import { injectContext, pass } from '../../shared/hook-response.js';
+import { getCommandSignature } from '../../shared/payload-utils.js';
+import { logEvent } from '../../shared/activity-logger.js';
+
+const MAX_BUFFER = 15;
+const LOOP_WINDOW = 8;
+const MAX_UNIQUE_SIGS = 2;
+const COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes
+
+try {
+  if (!stateExists()) pass();
+
+  const payload = await readStdin();
+  if (!payload) pass();
+
+  const cwd = process.cwd();
+  const memoryDir = join(cwd, '.morph', 'memory');
+  const bufferPath = join(memoryDir, 'action-buffer.json');
+  const cooldownPath = join(memoryDir, 'loop-cooldown.json');
+
+  mkdirSync(memoryDir, { recursive: true });
+
+  // Read existing buffer
+  let buffer = [];
+  try {
+    if (existsSync(bufferPath)) {
+      buffer = JSON.parse(readFileSync(bufferPath, 'utf-8'));
+      if (!Array.isArray(buffer)) buffer = [];
+    }
+  } catch {
+    buffer = [];
+  }
+
+  // Append current action
+  const sig = getCommandSignature(payload);
+  buffer.push({ sig, ts: new Date().toISOString() });
+
+  // Trim to max size (FIFO)
+  if (buffer.length > MAX_BUFFER) {
+    buffer = buffer.slice(-MAX_BUFFER);
+  }
+
+  // Save updated buffer
+  writeFileSync(bufferPath, JSON.stringify(buffer), 'utf-8');
+
+  // Check for loop (need at least LOOP_WINDOW actions)
+  if (buffer.length < LOOP_WINDOW) pass();
+
+  const recent = buffer.slice(-LOOP_WINDOW);
+  const uniqueSigs = new Set(recent.map(a => a.sig));
+
+  if (uniqueSigs.size > MAX_UNIQUE_SIGS) pass();
+
+  // Check cooldown
+  try {
+    if (existsSync(cooldownPath)) {
+      const cooldown = JSON.parse(readFileSync(cooldownPath, 'utf-8'));
+      const elapsed = Date.now() - new Date(cooldown.lastDetected).getTime();
+      if (elapsed < COOLDOWN_MS) pass();
+    }
+  } catch {
+    // Ignore corrupt cooldown — proceed with detection
+  }
+
+  // Loop detected — set cooldown and warn
+  writeFileSync(cooldownPath, JSON.stringify({ lastDetected: new Date().toISOString() }), 'utf-8');
+
+  logEvent('loop_detected', { signatures: uniqueSigs.size }, process.cwd());
+
+  const sigList = [...uniqueSigs].join(', ');
+  injectContext(
+    `⚠️ [morph-spec] LOOP DETECTED — the last ${LOOP_WINDOW} actions repeat only ${uniqueSigs.size} pattern(s): ${sigList}\n\n` +
+    `This usually means you're stuck. Stop and try a different approach:\n` +
+    `  1. Re-read the error message carefully — what is it actually saying?\n` +
+    `  2. Try a completely different fix strategy\n` +
+    `  3. If the test keeps failing, check if the test itself is wrong\n` +
+    `  4. If blocked, ask the user for guidance\n\n` +
+    `Do NOT continue the same pattern.`
+  );
+} catch {
+  // Fail-open
+  process.exit(0);
+}

package/framework/hooks/claude-code/session-start/inject-morph-context.js

@@ -12,9 +12,10 @@
  */
 
 import { loadState, getActiveFeature, getPendingGates, getMissingOutputs, derivePhaseForFeature, getTaskStats } from '../../shared/state-reader.js';
+import { loadSessionSnapshot, formatPreviousSession } from '../../shared/session-snapshot.js';
 import { stateExists } from '../../shared/state-reader.js';
 import { injectContext, pass } from '../../shared/hook-response.js';
-import { resetActivity, logHookActivity } from '../../shared/activity-logger.js';
+import { resetActivity, logHookActivity, archiveSession, logEvent } from '../../shared/activity-logger.js';
 import { readFileSync, existsSync, writeFileSync, renameSync, unlinkSync, statSync } from 'fs';
 import { join } from 'path';
 import { resetStaleTasks } from '../../shared/stale-task-reset.js';
@@ -74,10 +75,14 @@ try {
 
   const active = getActiveFeature();
 
-  // Reset activity log for new session
+  // Archive previous session log before resetting
   const activeFeatureName = active?.name || '';
   const activePhase = active ? derivePhaseForFeature(active.name) : '';
+  archiveSession();
+
+  // Reset activity log for new session
   resetActivity(new Date().toISOString(), activeFeatureName, activePhase);
+  logEvent('session_start', { feature: activeFeatureName, phase: activePhase });
   logHookActivity('inject-morph-context', 'SessionStart', 'ok');
 
   // ── Stale task cleanup ──────────────────────────────────────────────────────
@@ -201,6 +206,20 @@ try {
       // Fail-open — worktree context must never block the session
     }
     // ────────────────────────────────────────────────────────────────────────────
+
+    // ── Previous session context ──────────────────────────────────────────────
+    // Inject summary from previous session for "getting up to speed"
+    try {
+      const snapshot = loadSessionSnapshot(process.cwd());
+      const previousSessionText = formatPreviousSession(snapshot);
+      if (previousSessionText) {
+        lines.push('');
+        lines.push(previousSessionText);
+      }
+    } catch {
+      // Fail-open — previous session context must never block
+    }
+    // ────────────────────────────────────────────────────────────────────────
   } else {
     // Show summary of all features
     const featureNames = Object.keys(state.features);

package/framework/hooks/claude-code/stop/validate-completion.js

@@ -20,11 +20,13 @@
 
 import { readFileSync, writeFileSync, existsSync } from 'fs';
 import { join } from 'path';
+import { runBuildCheck } from '../../shared/build-check.js';
+import { saveSessionSnapshot } from '../../shared/session-snapshot.js';
 import {
   stateExists, getActiveFeature, getMostRecentFeature, getMissingOutputs, derivePhaseForFeature,
 } from '../../shared/state-reader.js';
 import { injectContext, pass } from '../../shared/hook-response.js';
-import { logHookActivity } from '../../shared/activity-logger.js';
+import { logHookActivity, logEvent } from '../../shared/activity-logger.js';
 
 // Phases where compaction is strongly recommended before starting
 const COMPACT_TRIGGER_PHASES = new Set(['implement']);
@@ -82,6 +84,50 @@ try {
     );
   }
 
+  // ── Build/typecheck verification ──────────────────────────────────────────
+  // Stack-aware build check — advisory warning if build fails.
+  // Success is silent (no output on pass).
+  try {
+    const configPath = join(cwd, '.morph', 'config', 'config.json');
+    if (existsSync(configPath)) {
+      const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+      const stack = config?.project?.stack;
+      if (stack && currentPhase === 'implement') {
+        const buildResult = runBuildCheck(cwd, stack);
+        if (buildResult.status === 'fail') {
+          warnings.push('⚠ Build/typecheck failed:');
+          warnings.push(buildResult.output);
+          warnings.push('Fix build errors before ending session.');
+        }
+        // pass and skip → silent (success is silent)
+      }
+    }
+  } catch {
+    // Fail-open — build check must never block Stop
+  }
+  // ────────────────────────────────────────────────────────────────────────
+
+  // ── Session snapshot ──────────────────────────────────────────────────────
+  // Save session state for next session's "getting up to speed" routine.
+  try {
+    if (active) {
+      const { name, feature } = active;
+      const taskList = feature.taskList || [];
+      saveSessionSnapshot({
+        feature: name,
+        phase: currentPhase,
+        tasksCompleted: taskList.filter(t => t.status === 'completed').map(t => t.id),
+        tasksRemaining: taskList.filter(t => t.status === 'pending').map(t => t.id),
+        tasksInProgress: taskList.filter(t => t.status === 'in_progress').map(t => t.id),
+        buildStatus: 'skip',
+        lastEditedFiles: [],
+      }, cwd);
+    }
+  } catch {
+    // Fail-open — snapshot save must never block Stop
+  }
+  // ────────────────────────────────────────────────────────────────────────
+
   // ── Incomplete work checks ────────────────────────────────────────────────
 
   // Incomplete tasks during implement phase
@@ -152,6 +198,7 @@ try {
   ].join('\n');
 
   logHookActivity('validate-completion', 'Stop', `warnings(${warnings.length})`);
+  logEvent('session_end', { feature: name, phase: currentPhase, warnings: warnings.length });
   injectContext(message);
 } catch {
   process.exit(0);

package/framework/hooks/shared/activity-logger.js

@@ -11,7 +11,7 @@
  * - Windows-safe paths via path.join
  */
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'fs';
+import { readFileSync, writeFileSync, mkdirSync, existsSync, unlinkSync } from 'fs';
 import { join } from 'path';
 
 const LOGS_DIR = '.morph/logs';
@@ -103,3 +103,58 @@ export function resetActivity(sessionId, feature, phase, projectPath) {
     // Fail-silent
   }
 }
+
+/**
+ * Log a structured event to the session activity log.
+ *
+ * @param {string} type   - Event type (e.g., 'task_start', 'loop_detected')
+ * @param {Object} data   - Event data payload
+ * @param {string} [projectPath] - Project root (defaults to cwd)
+ */
+export function logEvent(type, data, projectPath) {
+  try {
+    const activityPath = getActivityPath(projectPath);
+    ensureLogsDir(projectPath);
+
+    const now = new Date();
+    const ts = now.toTimeString().slice(0, 8); // HH:MM:SS
+
+    const activity = readRaw(activityPath) || { sessionId: '', feature: '', phase: '', hooks: [], events: [] };
+    activity.events = activity.events || [];
+    activity.events.push({ type, data, ts });
+
+    writeFileSync(activityPath, JSON.stringify(activity, null, 2), 'utf-8');
+  } catch {
+    // Fail-silent
+  }
+}
+
+/**
+ * Archive current activity.json to sessions/ directory for historical logging.
+ * Called at the start of a new session.
+ *
+ * @param {string} [projectPath] - Project root (defaults to cwd)
+ */
+export function archiveSession(projectPath) {
+  try {
+    const activityPath = getActivityPath(projectPath);
+    if (!existsSync(activityPath)) return;
+
+    const data = readRaw(activityPath);
+    if (!data) return;
+
+    // Only archive if there are meaningful events
+    if ((!data.hooks || data.hooks.length === 0) && (!data.events || data.events.length === 0)) return;
+
+    const sessionsDir = join(projectPath || process.cwd(), LOGS_DIR, 'sessions');
+    mkdirSync(sessionsDir, { recursive: true });
+
+    const sessionId = (data.sessionId || new Date().toISOString()).replace(/[:.]/g, '-');
+    const archivePath = join(sessionsDir, `${sessionId}.json`);
+    writeFileSync(archivePath, JSON.stringify(data, null, 2), 'utf-8');
+
+    unlinkSync(activityPath);
+  } catch {
+    // Fail-silent
+  }
+}

package/framework/hooks/shared/build-check.js

@@ -0,0 +1,79 @@
+/**
+ * Build/Typecheck verification utility.
+ *
+ * Stack-aware: determines the correct build command based on project stack.
+ * Used by the Stop hook to verify code health before session ends.
+ *
+ * Pure functions — no I/O except the actual build execution.
+ */
+
+import { execSync } from 'child_process';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+/**
+ * Determine the build command for a given stack.
+ *
+ * @param {string} stack - Project stack (e.g., 'dotnet-nextjs', 'nextjs')
+ * @param {boolean} [hasTsConfig] - Whether tsconfig.json exists (for TS projects)
+ * @returns {string|null} Build command or null if no check available
+ */
+export function getBuildCommand(stack, hasTsConfig = false) {
+  if (!stack) return null;
+  const s = stack.toLowerCase();
+
+  if (s.includes('dotnet')) {
+    return 'dotnet build --no-restore --nologo -v q 2>&1 | tail -20';
+  }
+
+  if ((s.includes('nextjs') || s.includes('node') || s.includes('react')) && hasTsConfig) {
+    return 'npx tsc --noEmit 2>&1 | tail -20';
+  }
+
+  return null;
+}
+
+/**
+ * Parse build command result into a structured object.
+ *
+ * @param {number} exitCode - Process exit code (0 = success)
+ * @param {string} output - stdout+stderr from build
+ * @returns {{ status: 'pass'|'fail', output: string }}
+ */
+export function parseBuildResult(exitCode, output) {
+  const trimmed = (output || '').trim();
+  if (exitCode === 0) {
+    return { status: 'pass', output: '' };
+  }
+  // Truncate to last 20 lines
+  const lines = trimmed.split('\n');
+  const truncated = lines.slice(-20).join('\n');
+  return { status: 'fail', output: truncated };
+}
+
+/**
+ * Run build check for a project.
+ *
+ * @param {string} cwd - Project root directory
+ * @param {string} stack - Project stack string
+ * @param {number} [timeout=30000] - Timeout in ms
+ * @returns {{ status: 'pass'|'fail'|'skip', output: string }}
+ */
+export function runBuildCheck(cwd, stack, timeout = 30000) {
+  const hasTsConfig = existsSync(join(cwd, 'tsconfig.json'));
+  const cmd = getBuildCommand(stack, hasTsConfig);
+  if (!cmd) return { status: 'skip', output: '' };
+
+  try {
+    const output = execSync(cmd, {
+      cwd,
+      encoding: 'utf-8',
+      timeout,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    return parseBuildResult(0, output);
+  } catch (err) {
+    const output = (err.stdout || '') + (err.stderr || '');
+    return parseBuildResult(err.status || 1, output);
+  }
+}

package/framework/hooks/shared/payload-utils.js

@@ -37,3 +37,42 @@ export function getContentToValidate(payload) {
 export function isWriteOperation(payload) {
   return typeof payload?.tool_input?.content === 'string';
 }
+
+/**
+ * Get the tool name from a hook payload.
+ * @param {Object} payload - Hook payload from stdin
+ * @returns {string} Tool name or 'unknown'
+ */
+export function getToolName(payload) {
+  return payload?.tool_name || 'unknown';
+}
+
+/**
+ * Build a normalized signature for loop detection.
+ * - Edit/Write: "Edit:normalized/file/path"
+ * - Bash: "Bash:first two words" (e.g., "Bash:npm test")
+ * - Other: just the tool name
+ *
+ * @param {Object} payload - Hook payload from stdin
+ * @returns {string} Signature string
+ */
+export function getCommandSignature(payload) {
+  const tool = getToolName(payload);
+  if (tool === 'unknown') return 'unknown';
+
+  const input = payload?.tool_input;
+  if (!input) return tool;
+
+  if (tool === 'Edit' || tool === 'Write') {
+    const path = (input.file_path || input.path || '').replace(/\\/g, '/');
+    return path ? `${tool}:${path}` : tool;
+  }
+
+  if (tool === 'Bash') {
+    const cmd = (input.command || '').trim();
+    const words = cmd.split(/\s+/).slice(0, 2).join(' ');
+    return words ? `Bash:${words}` : 'Bash';
+  }
+
+  return tool;
+}

package/framework/hooks/shared/session-snapshot.js

@@ -0,0 +1,105 @@
+/**
+ * Session Snapshot — cross-session persistence utility
+ *
+ * Saves and loads session state for "getting up to speed" on next session.
+ * Single file (overwrites) — history preserved via git.
+ *
+ * Fail-silent: never throws.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync, unlinkSync } from 'fs';
+import { join } from 'path';
+
+const SNAPSHOT_PATH = '.morph/memory/session-snapshot.json';
+
+/**
+ * Save session snapshot atomically.
+ * @param {Object} data - Snapshot data
+ * @param {string} [projectPath] - Project root (defaults to cwd)
+ */
+export function saveSessionSnapshot(data, projectPath) {
+  try {
+    const root = projectPath || process.cwd();
+    const dir = join(root, '.morph', 'memory');
+    mkdirSync(dir, { recursive: true });
+
+    const snapshot = { ...data, savedAt: new Date().toISOString() };
+    const filePath = join(root, SNAPSHOT_PATH);
+    const tmpPath = `${filePath}.tmp.${process.pid}`;
+
+    writeFileSync(tmpPath, JSON.stringify(snapshot, null, 2), 'utf-8');
+    try {
+      renameSync(tmpPath, filePath);
+    } catch {
+      writeFileSync(filePath, JSON.stringify(snapshot, null, 2), 'utf-8');
+      try { unlinkSync(tmpPath); } catch { /* ignore */ }
+    }
+  } catch {
+    // Fail-silent
+  }
+}
+
+/**
+ * Load session snapshot.
+ * @param {string} [projectPath] - Project root (defaults to cwd)
+ * @returns {Object|null} Parsed snapshot or null
+ */
+export function loadSessionSnapshot(projectPath) {
+  try {
+    const filePath = join(projectPath || process.cwd(), SNAPSHOT_PATH);
+    if (!existsSync(filePath)) return null;
+    return JSON.parse(readFileSync(filePath, 'utf-8'));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Format snapshot as concise context string for SessionStart injection.
+ * Budget: max ~150 tokens (~600 chars).
+ *
+ * @param {Object|null} snapshot
+ * @returns {string|null} Formatted context or null
+ */
+export function formatPreviousSession(snapshot) {
+  if (!snapshot) return null;
+
+  const lines = ['=== PREVIOUS SESSION ==='];
+
+  // Header line
+  const date = snapshot.savedAt ? new Date(snapshot.savedAt).toISOString().slice(0, 16).replace('T', ' ') : '?';
+  const phase = snapshot.phase || '?';
+  const build = snapshot.buildStatus || 'unknown';
+  lines.push(`Last: ${date} | Phase: ${phase} | Build: ${build}`);
+
+  // Tasks (truncated)
+  const done = snapshot.tasksCompleted || [];
+  if (done.length > 0) {
+    const shown = done.slice(-5).join(', ');
+    const prefix = done.length > 5 ? `...${done.length} total, last: ` : '';
+    lines.push(`Done: ${prefix}${shown}`);
+  }
+
+  const wip = snapshot.tasksInProgress || [];
+  if (wip.length > 0) {
+    lines.push(`WIP: ${wip.join(', ')}`);
+  }
+
+  const remaining = snapshot.tasksRemaining || [];
+  if (remaining.length > 0) {
+    const shown = remaining.slice(0, 5).join(', ');
+    const suffix = remaining.length > 5 ? ` +${remaining.length - 5} more` : '';
+    lines.push(`Remaining: ${shown}${suffix}`);
+  }
+
+  // Files (truncated)
+  const files = snapshot.lastEditedFiles || [];
+  if (files.length > 0) {
+    const shown = files.slice(0, 3).join(', ');
+    const suffix = files.length > 3 ? ` +${files.length - 3} more` : '';
+    lines.push(`Files: ${shown}${suffix}`);
+  }
+
+  lines.push('===');
+  return lines.join('\n');
+}

package/framework/phases.json

@@ -35,7 +35,7 @@
       ],
       "requiredOutputs": ["uiDesignSystem"],
       "optionalOutputs": ["uiMockups", "uiComponents", "uiFlows"],
-      "recommendedMCPs": ["playwright", "context7"],
+      "recommendedMCPs": ["playwright", "context7", "stitch"],
       "pausePoints": [
         { "id": "uiux", "label": "Approve UI/UX Design" }
       ],