ctx-cc 3.5.0 → 4.1.0

package/agents/ctx-quality-mapper.md

@@ -1,12 +1,14 @@
 ---
 name: ctx-quality-mapper
-description: Quality mapper for CTX 3.0. Analyzes test coverage, lint status, type safety, and code smells. Part of parallel codebase mapping.
+description: Quality mapper for CTX 4.0. Analyzes test coverage, lint status, type safety, and code smells. Part of parallel codebase mapping.
 tools: Read, Write, Bash, Glob, Grep
-color: green
+model: haiku
+maxTurns: 15
+memory: project
 ---
 
 <role>
-You are a CTX 3.0 quality mapper. You analyze:
+You are a CTX 4.0 quality mapper. You analyze:
 - Test coverage and quality
 - Linting and formatting status
 - Type safety and strictness

package/agents/ctx-researcher.md

@@ -1,12 +1,14 @@
 ---
 name: ctx-researcher
-description: Research agent for CTX 2.1. Uses ArguSeek for web research and ChunkHound for semantic code search. Reads PRD story for context. Spawned when status = "initializing".
+description: Research agent for CTX 4.0. Uses ArguSeek for web research and ChunkHound for semantic code search. Reads PRD story for context. Spawned when status = "initializing".
 tools: Read, Write, Bash, Glob, Grep, mcp__arguseek__*, mcp__chunkhound__*
-color: blue
+model: opus
+maxTurns: 25
+memory: project
 ---
 
 <role>
-You are a CTX 2.1 researcher. Your job is to gather information for a PRD story before planning.
+You are a CTX 4.0 researcher. Your job is to gather information for a PRD story before planning.
 
 You use:
 1. **PRD.json** - Story title, description, and acceptance criteria

package/agents/ctx-reviewer.md

@@ -1,12 +1,14 @@
 ---
 name: ctx-reviewer
-description: Proactive error prevention agent for CTX 3.1. Reviews code changes BEFORE commit to catch errors early. Runs type checks, import validation, security scans, and best practice enforcement.
+description: Proactive error prevention agent for CTX 4.0. Reviews code changes BEFORE commit to catch errors early. Runs type checks, import validation, security scans, and best practice enforcement.
 tools: Read, Bash, Glob, Grep
-color: orange
+model: sonnet
+maxTurns: 25
+memory: project
 ---
 
 <role>
-You are a CTX 3.1 reviewer. Your job is to:
+You are a CTX 4.0 reviewer. Your job is to:
 1. Review code changes before they are committed
 2. Catch type errors, import issues, and security vulnerabilities
 3. Enforce best practices and patterns from CONTEXT.md
@@ -21,7 +23,7 @@ You are the last line of defense before code enters the codebase.
 ## Proactive vs Reactive
 
 **Reactive** (current): Write code → Commit → Fail build → Debug → Fix
-**Proactive** (CTX 3.1): Write code → Review → Fix → Commit (clean)
+**Proactive** (CTX 4.0): Write code → Review → Fix → Commit (clean)
 
 Catching errors before commit:
 - Saves debug cycles

package/agents/ctx-team-coordinator.md

@@ -1,12 +1,14 @@
 ---
 name: ctx-team-coordinator
-description: Team collaboration agent for CTX 3.2. Manages file locks, prevents conflicts, and coordinates notifications across team members.
+description: Team collaboration agent for CTX 4.0. Manages file locks, prevents conflicts, and coordinates notifications across team members.
 tools: Read, Write, Bash, Glob, Grep
-color: blue
+model: haiku
+maxTurns: 15
+memory: project
 ---
 
 <role>
-You are a CTX 3.2 team coordinator. You manage:
+You are a CTX 4.0 team coordinator. You manage:
 - File locking during execution
 - Conflict detection and resolution
 - Team notifications (Slack/Discord)

package/agents/ctx-tech-mapper.md

@@ -1,12 +1,14 @@
 ---
 name: ctx-tech-mapper
-description: Tech stack mapper for CTX 3.0. Analyzes languages, frameworks, dependencies, and versions. Part of parallel codebase mapping.
+description: Tech stack mapper for CTX 4.0. Analyzes languages, frameworks, dependencies, and versions. Part of parallel codebase mapping.
 tools: Read, Write, Bash, Glob, Grep
-color: blue
+model: haiku
+maxTurns: 15
+memory: project
 ---
 
 <role>
-You are a CTX 3.0 tech stack mapper. You analyze:
+You are a CTX 4.0 tech stack mapper. You analyze:
 - Programming languages and their proportions
 - Frameworks and libraries
 - Dependencies and versions

package/agents/ctx-verifier.md

@@ -1,12 +1,14 @@
 ---
 name: ctx-verifier
-description: Verification agent for CTX 2.3. Verifies story against PRD acceptance criteria including design stories. Updates passes flag on success. Spawned when status = "verifying".
+description: Verification agent for CTX 4.0. Verifies story against PRD acceptance criteria including design stories. Updates passes flag on success. Spawned when status = "verifying".
 tools: Read, Write, Glob, Grep, Bash, mcp__playwright__*, mcp__chrome-devtools__*, mcp__gemini-design__*
-color: red
+model: haiku
+maxTurns: 15
+memory: project
 ---
 
 <role>
-You are a CTX 2.3 verifier. Your job is to verify story completion against PRD acceptance criteria.
+You are a CTX 4.0 verifier. Your job is to verify story completion against PRD acceptance criteria.
 
 You verify based on story type:
 

package/bin/ctx.js

@@ -1,50 +1,222 @@
 #!/usr/bin/env node
 
+/**
+ * CTX 4.0 CLI — Thin installer for Claude Code.
+ *
+ * This CLI installs agents, skills, commands, and hooks into ~/.claude/.
+ * Orchestration happens INSIDE Claude Code via the Agent tool, not here.
+ */
+
 import { install } from '../src/install.js';
+import { discoverAgents, formatAgentTable } from '../src/agents.js';
+import { loadConfig, getByPath, setByPath, saveConfig, formatConfigTable } from '../src/config.js';
+import { analyzeDescriptions, formatAnalysis, calculateUpfrontTokens } from '../src/skills.js';
+import { updateProjectManifest, MANIFEST_VERSION } from '../src/capabilities.js';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
 
-const args = process.argv.slice(2);
-const options = {
-  global: args.includes('--global') || args.includes('-g'),
-  project: args.includes('--project') || args.includes('-p'),
-  force: args.includes('--force') || args.includes('-f'),
-  help: args.includes('--help') || args.includes('-h'),
-};
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+const AGENTS_DIR = path.join(PACKAGE_ROOT, 'agents');
+const CONFIG_PATH = path.join(PACKAGE_ROOT, 'templates', 'config.json');
+
+// ANSI helpers
+const cyan = (s) => `\x1b[36m${s}\x1b[0m`;
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const bold = (s) => `\x1b[1m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
 
-if (options.help) {
-  console.log(`
-\x1b[36m   ██████╗████████╗██╗  ██╗
+const VERSION = JSON.parse(
+  fs.readFileSync(path.join(PACKAGE_ROOT, 'package.json'), 'utf-8')
+).version;
+
+function printBanner() {
+  console.log(cyan(`
+   ██████╗████████╗██╗  ██╗
   ██╔════╝╚══██╔══╝╚██╗██╔╝
   ██║        ██║    ╚███╔╝
   ██║        ██║    ██╔██╗
   ╚██████╗   ██║   ██╔╝ ██╗
-   ╚═════╝   ╚═╝   ╚═╝  ╚═╝\x1b[0m
+   ╚═════╝   ╚═╝   ╚═╝  ╚═╝`));
+  console.log(`\n  ${bold('CTX 4.0')} ${dim(`v${VERSION}`)}`);
+  console.log('  Intelligent workflow orchestration for Claude Code.\n');
+}
 
-  \x1b[1mCTX 3.3 - Continuous Task eXecution\x1b[0m
-  Intelligent workflow orchestration for Claude Code.
-  20 agents. Learning system. Predictive planning. Self-healing.
+// --- Subcommands ---
 
-  \x1b[1mUsage:\x1b[0m
-    npx ctx-cc [options]
+function showHelp() {
+  printBanner();
+  console.log(`  ${bold('Usage:')}
+    npx ctx-cc [options]          Install CTX into Claude Code
+    npx ctx-cc list               List available agents
+    npx ctx-cc skills             Analyze agent skill descriptions
+    npx ctx-cc config list        Show configuration
+    npx ctx-cc config get <key>   Get config value
+    npx ctx-cc config set <k> <v> Set config value
+    npx ctx-cc update-manifest    Migrate project capability manifest
 
-  \x1b[1mOptions:\x1b[0m
+  ${bold('Install Options:')}
     --global, -g     Install to ~/.claude (default)
     --project, -p    Install to .claude in current directory
     --force, -f      Overwrite existing installation
     --help, -h       Show this help message
 
-  \x1b[1mExamples:\x1b[0m
-    npx ctx-cc --global      Install globally
-    npx ctx-cc --project     Install for current project only
+  ${bold('After Installation:')}
+    Launch Claude Code and use:
+      /ctx              Smart router — describe what you want
+      /ctx:help         Full command reference
+      /ctx:init         Initialize a project
+      /ctx:plan         Plan a story
+      /ctx:status       Check progress
 
-  \x1b[1mAfter Installation:\x1b[0m
-    Launch Claude Code and run /ctx:help
+  ${bold('Architecture:')}
+    CTX installs into Claude Code's native extension points:
+      ~/.claude/agents/     26 subagents (invoked via Agent tool)
+      ~/.claude/skills/     7 skills (auto-discovered by Claude)
+      ~/.claude/commands/   Slash commands (/ctx:*)
+      ~/.claude/hooks/      Deterministic enforcement scripts
 `);
-  process.exit(0);
 }
 
-// Default to global if no option specified
-if (!options.global && !options.project) {
-  options.global = true;
+function listAgents() {
+  const agents = discoverAgents(AGENTS_DIR);
+  if (agents.length === 0) {
+    console.log(red('  No agents found in agents/ directory.'));
+    process.exit(1);
+  }
+  printBanner();
+  console.log(`  ${bold(`${agents.length} Agents Available`)}\n`);
+  console.log(formatAgentTable(agents));
+  console.log(`\n  ${dim('Agents are invoked by Claude Code via the Agent tool.')}`);
+  console.log(`  ${dim('Use /ctx in Claude Code to interact with agents.')}\n`);
+}
+
+function handleConfig(subArgs) {
+  const [action, key, ...rest] = subArgs;
+  const config = loadConfig(CONFIG_PATH);
+
+  if (!action || action === 'list') {
+    printBanner();
+    console.log(`  ${bold('Configuration')}\n`);
+    console.log(formatConfigTable(config));
+    console.log();
+    return;
+  }
+
+  if (action === 'get') {
+    if (!key) {
+      console.error(red('  Error: config get requires a key. Run "ctx-cc config list" to see valid keys.'));
+      process.exit(1);
+    }
+    const val = getByPath(config, key);
+    if (val === undefined) {
+      console.error(red(`  Error: unknown key "${key}". Run "ctx-cc config list" to see valid keys.`));
+      process.exit(1);
+    }
+    console.log(JSON.stringify(val, null, 2));
+    return;
+  }
+
+  if (action === 'set') {
+    if (!key || rest.length === 0) {
+      console.error(red('  Error: usage: ctx-cc config set <key> <value>'));
+      process.exit(1);
+    }
+    const value = rest.join(' ');
+    if (getByPath(config, key) === undefined) {
+      console.error(red(`  Error: unknown key "${key}". Run "ctx-cc config list" to see valid keys.`));
+      process.exit(1);
+    }
+    setByPath(config, key, value);
+    saveConfig(CONFIG_PATH, config);
+    console.log(green(`  ✓ Set ${key} = ${JSON.stringify(getByPath(config, key))}`));
+    return;
+  }
+
+  console.error(red(`  Error: unknown config action "${action}". Use list, get, or set.`));
+  process.exit(1);
+}
+
+function handleUpdateManifest() {
+  const ctxDir = path.join(process.cwd(), '.ctx');
+  if (!fs.existsSync(ctxDir)) {
+    console.error(red(`  Error: no .ctx/ directory in ${process.cwd()}.`));
+    console.error(`  Run ${cyan('/ctx:init')} in Claude Code to initialize a project first.`);
+    process.exit(1);
+  }
+  printBanner();
+  const result = updateProjectManifest(ctxDir);
+  switch (result.action) {
+    case 'created':
+      console.log(green('  ✓') + ` Seeded capability-manifest.json at v${result.to}`);
+      console.log(`    ${dim('Path:')} ${result.path}`);
+      break;
+    case 'current':
+      console.log(green('  ✓') + ` Manifest already at v${result.to} — no change`);
+      break;
+    case 'migrated':
+      console.log(green('  ✓') + ` Migrated manifest v${result.from} → v${result.to}`);
+      console.log(`    ${dim('Backup:')} ${result.backup}`);
+      break;
+  }
+  console.log();
 }
 
-install(options);
+function handleSkills() {
+  const analysis = analyzeDescriptions(AGENTS_DIR);
+  const { totalTokens, agentCount } = calculateUpfrontTokens(AGENTS_DIR);
+  printBanner();
+  console.log(`  ${bold('Skills Analysis')}\n`);
+  console.log(formatAnalysis(analysis));
+  console.log(`\n  ${dim('Target: <2500 tokens total for all descriptions (progressive disclosure).')}`);
+  console.log(`  ${dim('Current: ~${totalTokens} tokens for ${agentCount} agents.')}\n`);
+}
+
+// --- Main ---
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+const flags = {
+  global: args.includes('--global') || args.includes('-g'),
+  project: args.includes('--project') || args.includes('-p'),
+  force: args.includes('--force') || args.includes('-f'),
+  help: args.includes('--help') || args.includes('-h'),
+};
+
+if (flags.help && !command) {
+  showHelp();
+  process.exit(0);
+}
+
+switch (command) {
+  case 'list':
+    listAgents();
+    break;
+
+  case 'config':
+    handleConfig(args.slice(1));
+    break;
+
+  case 'skills':
+    handleSkills();
+    break;
+
+  case 'update-manifest':
+    handleUpdateManifest();
+    break;
+
+  case '--help':
+  case '-h':
+    showHelp();
+    break;
+
+  default:
+    // Default: install (backward compatible)
+    if (!flags.global && !flags.project) flags.global = true;
+    install(flags);
+    break;
+}

package/commands/brand.md

@@ -0,0 +1,309 @@
+---
+name: ctx:brand
+description: Establish visual foundation — front-loaded discovery, competitive research, mood board, 3 brand directions, BRAND_KIT.md, W3C DTCG tokens. Mandatory approval gates at every phase.
+---
+
+<objective>
+Build the visual foundation for a project from scratch. Produces BRAND_KIT.md, a three-tier W3C token system, and exported style assets. Every approval gate is mandatory — no phase is skipped.
+</objective>
+
+<usage>
+```bash
+/ctx:brand                  # Full brand establishment workflow
+/ctx:brand --update         # Update existing brand (adds to BRAND_KIT.md, extends tokens)
+/ctx:brand --tokens-only    # Regenerate token files from existing BRAND_KIT.md
+/ctx:brand --export         # Re-export brand-assets/ from current tokens
+```
+</usage>
+
+<process>
+
+## Step 1: Check Existing Brand State
+
+```bash
+# Check if BRAND_KIT.md already exists
+ls BRAND_KIT.md 2>/dev/null && echo "EXISTS" || echo "MISSING"
+ls tokens/ 2>/dev/null && ls tokens/*.tokens.json 2>/dev/null || echo "NO_TOKENS"
+```
+
+**If BRAND_KIT.md exists and not `--update` flag:**
+
+```
+BRAND_KIT.md already exists in this project.
+
+Current version: [read from BRAND_KIT.md header]
+
+Options:
+  A  Update brand — extend colors, typography, or tokens
+  B  Rebuild brand — start fresh (will overwrite BRAND_KIT.md)
+  C  Export only — regenerate brand-assets/ from current tokens
+  D  Cancel
+
+Proceed with: ?
+```
+
+## Step 2: Load Project Context
+
+Read PRD for product understanding:
+
+```bash
+python3 -c "
+import json, sys
+try:
+    with open('.ctx/PRD.json') as f:
+        prd = json.load(f)
+    print('PROJECT:', prd.get('project', {}).get('name', 'Unknown'))
+    print('DESCRIPTION:', prd.get('project', {}).get('description', ''))
+    print('TARGET_USER:', prd.get('context', {}).get('targetUser', ''))
+    print('PROBLEM:', prd.get('context', {}).get('problem', ''))
+except:
+    print('NO_PRD')
+"
+```
+
+## Step 3: Front-Loaded Discovery
+
+**Ask ALL questions upfront in one block.** Do not ask one at a time.
+
+```
+Before I begin visual research, I need to understand your brand direction.
+Answer all questions — you can be brief. I'll handle the details.
+
+1. FEELING
+   What 3-5 adjectives should describe this product's visual feel?
+   (e.g., "bold, modern, trustworthy" or "warm, approachable, friendly")
+
+2. INSPIRATION
+   Name 2-3 products, brands, or websites whose visual design you admire.
+   (e.g., "Linear, Stripe, Apple" — doesn't have to be in your industry)
+
+3. AVOID
+   Any visual styles you strongly want to avoid?
+   (e.g., "no gradients", "nothing corporate/boring", "no dark backgrounds")
+
+4. EXISTING ASSETS
+   Do you have any existing brand assets?
+   - Logo file? (yes/no — share path if yes)
+   - Existing colors? (share hex codes if yes)
+   - Existing fonts? (share names if yes)
+   - Figma file? (share file key if yes)
+
+5. MODES
+   Light mode only / Dark mode only / Both?
+
+6. MARKET
+   EU market? (affects EAA 2025 accessibility compliance requirements)
+
+7. AUDIENCE
+   Who is the primary user? (tech-savvy pros / general consumers / enterprise / other)
+```
+
+Save answers to `.ctx/phases/brand/DISCOVERY.md`:
+
+```markdown
+# Brand Discovery
+
+**Date:** [ISO-8601]
+**Project:** [name from PRD or user]
+
+## Answers
+
+### Desired Feeling
+[adjectives]
+
+### Visual Inspiration
+[list]
+
+### Styles to Avoid
+[list]
+
+### Existing Assets
+- Logo: [yes/no, path]
+- Colors: [values or none]
+- Fonts: [names or none]
+- Figma: [file key or none]
+
+### Mode Support
+[light/dark/both]
+
+### Market
+[EU: yes/no]
+
+### Audience
+[description]
+```
+
+## Step 4: Spawn ctx-designer — Brand Workflow
+
+With all discovery answers in hand, spawn the designer for the full brand workflow:
+
+```
+Agent({
+  subagent_type: "ctx-designer",
+  prompt: "
+    Execute the full brand establishment workflow.
+
+    Story type: brand
+    Story ID: brand-001
+    Phase storage: .ctx/phases/brand/
+
+    Project context:
+    [paste PRD summary: name, description, target user, problem]
+
+    Discovery answers:
+    [paste full DISCOVERY.md content]
+
+    Brand workflow phases (execute in order):
+    1. Phase 2: Competitive Visual Research
+       - ArguSeek: research '[product type] visual design trends 2025'
+       - Browse 10-15 references (Dribbble, Behance, Awwwards, Mobbin)
+       - Save screenshots to .ctx/phases/brand/refs/
+
+    2. Phase 3: Mood Board
+       - Create .ctx/phases/brand/MOOD_BOARD.md
+       - Include: visual direction summary, reference gallery, color themes, typography directions, patterns to adopt, patterns to avoid
+       - STOP — wait for approval before continuing
+
+    3. Phase 4: Generate 3 Brand Directions
+       After mood board approval:
+       - Option A: Conservative — safe, traditional, low risk
+       - Option B: Balanced    — modern, accessible, recommended
+       - Option C: Bold        — distinctive, higher risk/reward
+       - Generate visual for each using Gemini
+       - Save to .ctx/phases/brand/option-a.png, option-b.png, option-c.png
+       - Present side-by-side comparison with: colors (hex), fonts, feel adjectives
+       - STOP — wait for direction selection
+
+    5. Phase 5: Build Token System
+       After direction selection:
+       - Create tokens/primitive.tokens.json (W3C DTCG, oklch color space)
+       - Create tokens/semantic.tokens.json (mode-aware light/dark)
+       - Create tokens/component.tokens.json (button, input, card at minimum)
+       - Create tokens/themes/light.tokens.json
+       - Create tokens/themes/dark.tokens.json (if dark mode requested)
+       - All tokens must pass contrast audit before proceeding:
+         * Text pairs: 4.5:1 minimum
+         * UI component pairs: 3:1 minimum
+
+    6. Phase 6: Create BRAND_KIT.md
+       - Write comprehensive brand kit to project root
+       - Include: brand essence, token architecture, full color system with accessibility table, typography stack, spacing system, motion tokens, do's and don'ts
+
+    7. Phase 7: Generate Exports
+       - brand-assets/tokens.css (CSS custom properties)
+       - brand-assets/tokens.scss (SCSS variables)
+       - brand-assets/tokens.js (JS constants)
+       - brand-assets/tailwind.config.js (Tailwind theme extension)
+
+    Approval gates:
+    - Gate 1: Mood board approval (Phase 3) — MANDATORY STOP
+    - Gate 2: Direction selection (Phase 4) — MANDATORY STOP
+    - Gate 3: Token contrast audit (Phase 5) — auto, fix if fail
+    - Gate 4: Final BRAND_KIT.md review — MANDATORY STOP
+
+    Do NOT proceed past a gate without explicit approval.
+  ",
+  description: "Establish brand: [project name]"
+})
+```
+
+## Step 5: Track Approval Gates in STATE.json
+
+After each gate is passed, record it:
+
+```bash
+python3 -c "
+import json, sys
+from datetime import datetime
+
+with open('.ctx/STATE.json', 'r') as f:
+    state = json.load(f)
+
+state.setdefault('brand', {})
+state['brand']['discoveryComplete'] = True
+state['brand']['discoveryAt'] = datetime.utcnow().isoformat() + 'Z'
+state['brand']['approvalGates'] = {
+    'moodBoard':  { 'approved': False, 'approvedAt': None },
+    'direction':  { 'approved': False, 'selectedOption': None, 'approvedAt': None },
+    'brandKit':   { 'approved': False, 'approvedAt': None }
+}
+
+with open('.ctx/STATE.json', 'w') as f:
+    json.dump(state, f, indent=2)
+
+print('STATE.json updated')
+"
+```
+
+When each gate is passed, update the corresponding entry:
+
+```bash
+# Example: mark mood board approved
+python3 -c "
+import json
+from datetime import datetime
+
+with open('.ctx/STATE.json', 'r') as f:
+    state = json.load(f)
+
+state['brand']['approvalGates']['moodBoard']['approved'] = True
+state['brand']['approvalGates']['moodBoard']['approvedAt'] = datetime.utcnow().isoformat() + 'Z'
+
+with open('.ctx/STATE.json', 'w') as f:
+    json.dump(state, f, indent=2)
+"
+```
+
+## Step 6: Post-Brand Summary
+
+After all gates pass and exports are generated:
+
+```
+[CTX BRAND] Complete
+
+Files created:
+  BRAND_KIT.md                      Visual brand reference
+  tokens/primitive.tokens.json      Raw value scale
+  tokens/semantic.tokens.json       Purpose aliases (light/dark)
+  tokens/component.tokens.json      Component tokens
+  tokens/themes/dark.tokens.json    Dark mode overrides (if applicable)
+  brand-assets/tokens.css           CSS custom properties
+  brand-assets/tokens.scss          SCSS variables
+  brand-assets/tokens.js            JS constants
+  brand-assets/tailwind.config.js   Tailwind theme
+
+Approval gates passed:
+  [x] Mood board approved
+  [x] Direction selected: Option [A/B/C]
+  [x] BRAND_KIT.md approved
+
+Accessibility:
+  Contrast audit: PASS
+  Touch target tokens: 44px minimum defined
+  EAA 2025: [compliant / not applicable]
+
+Next steps:
+  /ctx:design   — Start designing components using the brand
+  /ctx:qa       — Run full quality assurance
+```
+
+</process>
+
+<output>
+```
+[CTX BRAND] Brand Establishment
+
+Project: [name]
+Mode: [full / update / tokens-only / export]
+
+[Discovery collected]
+[Spawning ctx-designer — brand workflow]
+
+[Gate 1] Mood board → waiting for approval
+[Gate 2] Direction selection → waiting for approval
+[Gate 3] Contrast audit → auto
+[Gate 4] BRAND_KIT.md final → waiting for approval
+
+[Agent output follows]
+```
+</output>