bastard-framework 1.0.0

package/dist/cli.js

@@ -0,0 +1,3142 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+import { existsSync as existsSync10, mkdirSync as mkdirSync5 } from "fs";
+import { basename, resolve as resolve3 } from "path";
+
+// src/rounds.ts
+var ROUNDS = [
+  {
+    id: 1,
+    name: "Vision & Product",
+    shortName: "product",
+    frameworks: ["bmad"],
+    description: "Transformer une idee en PRD actionnable. Zero code avant ca.",
+    gateChecks: [
+      {
+        id: "prd-content",
+        description: "PRD.md has real content (not just template)",
+        type: "content_validated",
+        schemaKey: "prd"
+      },
+      {
+        id: "personas-content",
+        description: "PERSONAS.md has real content",
+        type: "content_validated",
+        schemaKey: "personas"
+      },
+      {
+        id: "acceptance-content",
+        description: "ACCEPTANCE_CRITERIA.md has real content with AC-XXX format",
+        type: "content_validated",
+        schemaKey: "acceptance"
+      },
+      {
+        id: "round1-approval",
+        description: "Human approved Round 1 outputs",
+        type: "human_approval"
+      }
+    ]
+  },
+  {
+    id: 2,
+    name: "Design System & UX",
+    shortName: "design",
+    frameworks: ["gstack", "turbo"],
+    description: "Poser l'identite visuelle avant de toucher au CSS.",
+    gateChecks: [
+      {
+        id: "design-content",
+        description: "DESIGN.md has real tokens (colors, typography, spacing)",
+        type: "content_validated",
+        schemaKey: "design"
+      },
+      {
+        id: "round2-approval",
+        description: "Human approved design system",
+        type: "human_approval"
+      }
+    ]
+  },
+  {
+    id: 3,
+    name: "Architecture",
+    shortName: "architecture",
+    frameworks: ["bmad", "super"],
+    description: "Les decisions techniques ecrites avant d'etre codees.",
+    gateChecks: [
+      {
+        id: "arch-content",
+        description: "ARCHITECTURE.md has real content (stack, data model)",
+        type: "content_validated",
+        schemaKey: "architecture"
+      },
+      {
+        id: "adr-validated",
+        description: "At least 1 valid ADR (proper Status/Context/Decision/Consequences)",
+        type: "adr_validated"
+      },
+      {
+        id: "round3-approval",
+        description: "Human approved architecture",
+        type: "human_approval"
+      }
+    ]
+  },
+  {
+    id: 4,
+    name: "Decomposition & Planification",
+    shortName: "planning",
+    frameworks: ["taskm", "gsd"],
+    description: "Transformer l'architecture en taches executables sans ambiguite.",
+    gateChecks: [
+      {
+        id: "context-exists",
+        description: "CONTEXT.md exists",
+        type: "file_exists",
+        path: "docs/planning/CONTEXT.md"
+      },
+      {
+        id: "tasks-exist",
+        description: "Task files exist",
+        type: "min_count",
+        path: "tasks",
+        minCount: 1
+      }
+    ]
+  },
+  {
+    id: 5,
+    name: "Execution du Code",
+    shortName: "execution",
+    frameworks: ["gsd", "super"],
+    description: "Builder sans context rot, avec le bon cerveau au bon moment.",
+    gateChecks: [
+      {
+        id: "src-exists",
+        description: "Source code exists",
+        type: "min_count",
+        path: "src",
+        minCount: 1
+      },
+      {
+        id: "tests-exist",
+        description: "Tests exist",
+        type: "min_count",
+        path: "tests",
+        minCount: 1
+      }
+    ]
+  },
+  {
+    id: 6,
+    name: "Securite",
+    shortName: "security",
+    frameworks: ["tob", "super"],
+    description: "La securite est integree au build, pas ajoutee apres livraison.",
+    gateChecks: [
+      {
+        id: "threat-model-content",
+        description: "THREAT_MODEL.md has STRIDE analysis",
+        type: "content_validated",
+        schemaKey: "threat_model"
+      },
+      {
+        id: "security-review-content",
+        description: "SECURITY_REVIEW.md has OWASP checklist + findings",
+        type: "content_validated",
+        schemaKey: "security_review"
+      }
+    ]
+  },
+  {
+    id: 7,
+    name: "QA & Tests",
+    shortName: "qa",
+    frameworks: ["gstack"],
+    description: "Verifier que ce qu'on a bati marche vraiment.",
+    gateChecks: [
+      {
+        id: "round7-approval",
+        description: "QA passed \u2014 Design Score >= B, AI Slop Score = A",
+        type: "human_approval"
+      }
+    ]
+  },
+  {
+    id: 8,
+    name: "Review & Livraison",
+    shortName: "shipping",
+    frameworks: ["gstack", "gsd"],
+    description: "Shipper ce qu'on avait prevu de shipper, ni plus ni moins.",
+    gateChecks: [
+      {
+        id: "acceptance-pass",
+        description: "Acceptance criteria 100% green",
+        type: "human_approval"
+      }
+    ]
+  }
+];
+function getRound(id) {
+  return ROUNDS.find((r) => r.id === id);
+}
+
+// src/state.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+var STATE_DIR = ".bastard";
+var STATE_FILE = "state.json";
+function getStatePath(projectRoot) {
+  return join(projectRoot, STATE_DIR, STATE_FILE);
+}
+function stateExists(projectRoot) {
+  return existsSync(getStatePath(projectRoot));
+}
+function createInitialState(projectName) {
+  const rounds = {};
+  for (const round of ROUNDS) {
+    rounds[String(round.id)] = {
+      status: round.id === 1 ? "active" : "locked",
+      gate: "pending",
+      gateResults: [],
+      startedAt: round.id === 1 ? (/* @__PURE__ */ new Date()).toISOString() : null,
+      completedAt: null
+    };
+  }
+  return {
+    version: "0.1.0",
+    project: projectName,
+    currentRound: 1,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    rounds,
+    history: [
+      {
+        action: "init",
+        round: 1,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        details: `Project "${projectName}" initialized`
+      }
+    ]
+  };
+}
+function saveState(projectRoot, state) {
+  const dir = join(projectRoot, STATE_DIR);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  writeFileSync(getStatePath(projectRoot), JSON.stringify(state, null, 2) + "\n");
+}
+function loadState(projectRoot) {
+  const path = getStatePath(projectRoot);
+  if (!existsSync(path)) {
+    throw new Error("No BASTARD project found. Run `bastard init` first.");
+  }
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    throw new Error(
+      `Corrupted state file: ${path}
+Run 'bastard reset' to reinitialize or fix the JSON manually.`
+    );
+  }
+}
+function addHistory(state, action, round, details) {
+  state.history.push({
+    action,
+    round,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    details
+  });
+}
+function advanceRound(state) {
+  const current = state.currentRound;
+  const currentState = state.rounds[String(current)];
+  if (!currentState || currentState.gate !== "passed") {
+    return false;
+  }
+  currentState.status = "completed";
+  currentState.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const nextRound = current + 1;
+  if (nextRound > 8) {
+    addHistory(state, "project_complete", current, "All 8 rounds completed");
+    return true;
+  }
+  state.currentRound = nextRound;
+  state.rounds[String(nextRound)].status = "active";
+  state.rounds[String(nextRound)].startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  addHistory(state, "advance", nextRound, `Advanced to Round ${nextRound}`);
+  return true;
+}
+function approveGate(state, roundId) {
+  const roundState = state.rounds[String(roundId)];
+  if (!roundState) return;
+  const round = ROUNDS.find((r) => r.id === roundId);
+  if (!round) return;
+  for (const check of round.gateChecks) {
+    if (check.type === "human_approval") {
+      const existing = roundState.gateResults.findIndex((r) => r.checkId === check.id);
+      const result = {
+        checkId: check.id,
+        passed: true,
+        message: "Approved by human",
+        checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      if (existing >= 0) {
+        roundState.gateResults[existing] = result;
+      } else {
+        roundState.gateResults.push(result);
+      }
+    }
+  }
+  addHistory(state, "approve", roundId, `Human approved Round ${roundId} gate`);
+}
+
+// src/gates.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3, readdirSync as readdirSync2 } from "fs";
+import { join as join3 } from "path";
+
+// src/schemas.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync } from "fs";
+import { join as join2 } from "path";
+var SCHEMAS = {
+  prd: {
+    path: "docs/product/PRD.md",
+    description: "Product Requirements Document",
+    sections: [
+      { heading: "## Problem", minContentLength: 100 },
+      { heading: "## Users", minContentLength: 50 },
+      { heading: "## User Stories", minContentLength: 80, pattern: /As a .+, I want .+ so that/, patternDescription: 'At least one user story in "As a..., I want... so that..." format' },
+      { heading: "## Success Metrics", minContentLength: 50 },
+      { heading: "## Scope", minContentLength: 30 }
+    ]
+  },
+  personas: {
+    path: "docs/product/PERSONAS.md",
+    description: "User Personas",
+    sections: [
+      { heading: "## Persona 1", minContentLength: 100 },
+      { heading: "## Persona 2", minContentLength: 100 }
+    ]
+  },
+  acceptance: {
+    path: "docs/product/ACCEPTANCE_CRITERIA.md",
+    description: "Acceptance Criteria",
+    sections: [
+      { heading: "## Core Criteria", minContentLength: 50, pattern: /AC-\d{3}/, patternDescription: "At least one criterion in AC-XXX format" }
+    ]
+  },
+  design: {
+    path: "docs/design/DESIGN.md",
+    description: "Design System",
+    sections: [
+      { heading: "## Color", minContentLength: 50, pattern: /--color-/, patternDescription: "At least one CSS custom property (--color-*)" },
+      { heading: "## Typography", minContentLength: 50, pattern: /--font-|--text-/, patternDescription: "At least one typography token" },
+      { heading: "## Spacing", minContentLength: 30 }
+    ]
+  },
+  architecture: {
+    path: "docs/architecture/ARCHITECTURE.md",
+    description: "Architecture Document",
+    sections: [
+      { heading: "## Stack", minContentLength: 50 },
+      { heading: "## Data Model", minContentLength: 30 }
+    ]
+  },
+  adr: {
+    path: "",
+    // validated per-file in ADR directory
+    description: "Architecture Decision Record",
+    sections: [
+      { heading: "## Status", minContentLength: 5, pattern: /Proposed|Accepted|Rejected|Superseded/, patternDescription: "Valid status: Proposed, Accepted, Rejected, or Superseded" },
+      { heading: "## Context", minContentLength: 50 },
+      { heading: "## Decision", minContentLength: 30 },
+      { heading: "## Consequences", minContentLength: 30 }
+    ]
+  },
+  threat_model: {
+    path: "docs/security/THREAT_MODEL.md",
+    description: "Threat Model",
+    sections: [
+      { heading: "## Assets", minContentLength: 30 },
+      { heading: "## STRIDE", minContentLength: 50 }
+    ]
+  },
+  security_review: {
+    path: "docs/security/SECURITY_REVIEW.md",
+    description: "Security Review",
+    sections: [
+      { heading: "## OWASP Top 10", minContentLength: 50 },
+      { heading: "## Findings", minContentLength: 10 }
+    ]
+  }
+};
+function extractSection(content, heading) {
+  const level = heading.match(/^#+/)?.[0].length ?? 2;
+  const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const pattern = new RegExp(`${escapedHeading}[^
+]*
+([\\s\\S]*?)(?=
+#{1,${level}} |$)`);
+  const match = content.match(pattern);
+  if (!match) return null;
+  return match[1].trim();
+}
+function validateDocument(projectRoot, schema, filePath) {
+  const docPath = filePath ?? schema.path;
+  const fullPath = join2(projectRoot, docPath);
+  if (!existsSync2(fullPath)) {
+    return {
+      path: docPath,
+      description: schema.description,
+      fileExists: false,
+      sections: [],
+      allPassed: false
+    };
+  }
+  const content = readFileSync2(fullPath, "utf-8");
+  const sections = schema.sections.map((rule) => {
+    const sectionContent = extractSection(content, rule.heading);
+    const exists = sectionContent !== null;
+    const contentLength = sectionContent?.length ?? 0;
+    const strippedContent = sectionContent?.replace(/^[-*]\s*$/gm, "").replace(/\|[\s|]*\|/g, "").replace(/^\s*$/gm, "").trim() ?? "";
+    const realLength = strippedContent.length;
+    const meetsMinLength = realLength >= rule.minContentLength;
+    let patternMatched = null;
+    if (rule.pattern && sectionContent) {
+      patternMatched = rule.pattern.test(sectionContent);
+    } else if (rule.pattern) {
+      patternMatched = false;
+    }
+    return {
+      heading: rule.heading,
+      exists,
+      contentLength: realLength,
+      meetsMinLength,
+      patternMatched,
+      patternDescription: rule.patternDescription
+    };
+  });
+  const allPassed = sections.every(
+    (s) => s.exists && s.meetsMinLength && (s.patternMatched === null || s.patternMatched)
+  );
+  return {
+    path: docPath,
+    description: schema.description,
+    fileExists: true,
+    sections,
+    allPassed
+  };
+}
+function validateADRs(projectRoot) {
+  const adrDir = join2(projectRoot, "docs/architecture/ADR");
+  if (!existsSync2(adrDir)) {
+    return { count: 0, valid: 0, invalid: [] };
+  }
+  const files = readdirSync(adrDir).filter((f) => f.endsWith(".md") && f !== "ADR-000-template.md" && !f.startsWith("."));
+  const invalid = [];
+  let valid = 0;
+  for (const file of files) {
+    const result = validateDocument(projectRoot, SCHEMAS.adr, `docs/architecture/ADR/${file}`);
+    if (result.allPassed) {
+      valid++;
+    } else {
+      invalid.push(file);
+    }
+  }
+  return { count: files.length, valid, invalid };
+}
+
+// src/gates.ts
+function checkFileExists(projectRoot, check) {
+  const fullPath = join3(projectRoot, check.path);
+  const exists = existsSync3(fullPath);
+  return {
+    checkId: check.id,
+    passed: exists,
+    message: exists ? `${check.path} exists` : `${check.path} not found`,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function checkFileSections(projectRoot, check) {
+  const fullPath = join3(projectRoot, check.path);
+  if (!existsSync3(fullPath)) {
+    return {
+      checkId: check.id,
+      passed: false,
+      message: `${check.path} not found \u2014 cannot check sections`,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const content = readFileSync3(fullPath, "utf-8");
+  const missing = (check.sections ?? []).filter((s) => !content.includes(s));
+  return {
+    checkId: check.id,
+    passed: missing.length === 0,
+    message: missing.length === 0 ? `All required sections present in ${check.path}` : `Missing sections in ${check.path}: ${missing.join(", ")}`,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function checkMinCount(projectRoot, check) {
+  const fullPath = join3(projectRoot, check.path);
+  if (!existsSync3(fullPath)) {
+    return {
+      checkId: check.id,
+      passed: false,
+      message: `Directory ${check.path} not found`,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const files = readdirSync2(fullPath).filter((f) => !f.startsWith("."));
+  const count = files.length;
+  const min = check.minCount ?? 1;
+  return {
+    checkId: check.id,
+    passed: count >= min,
+    message: count >= min ? `${check.path}: ${count} file(s) found (min: ${min})` : `${check.path}: ${count} file(s) found, need at least ${min}`,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function checkHumanApproval(state, roundId, check) {
+  const roundState = state.rounds[String(roundId)];
+  const existing = roundState?.gateResults.find((r) => r.checkId === check.id);
+  if (existing?.passed) {
+    return existing;
+  }
+  return {
+    checkId: check.id,
+    passed: false,
+    message: `Awaiting human approval. Run: bastard approve ${roundId}`,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function checkContentValidated(projectRoot, check, details) {
+  const schemaKey = check.schemaKey;
+  if (!schemaKey || !SCHEMAS[schemaKey]) {
+    return {
+      checkId: check.id,
+      passed: false,
+      message: `Schema "${schemaKey}" not found`,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const schema = SCHEMAS[schemaKey];
+  const validation = validateDocument(projectRoot, schema);
+  details.set(check.id, validation);
+  if (!validation.fileExists) {
+    return {
+      checkId: check.id,
+      passed: false,
+      message: `${schema.path} not found`,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  if (validation.allPassed) {
+    return {
+      checkId: check.id,
+      passed: true,
+      message: `${schema.path} \u2014 all content validated`,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  const failures = [];
+  for (const s of validation.sections) {
+    if (!s.exists) {
+      failures.push(`missing section "${s.heading}"`);
+    } else if (!s.meetsMinLength) {
+      failures.push(`"${s.heading}" too short (${s.contentLength}/${SCHEMAS[schemaKey].sections.find((r) => r.heading === s.heading)?.minContentLength ?? 0} chars)`);
+    } else if (s.patternMatched === false) {
+      failures.push(`"${s.heading}" missing pattern: ${s.patternDescription ?? "required format"}`);
+    }
+  }
+  return {
+    checkId: check.id,
+    passed: false,
+    message: `${schema.path} \u2014 ${failures.join("; ")}`,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function checkADRValidated(projectRoot, check, details) {
+  const result = validateADRs(projectRoot);
+  if (result.count === 0) {
+    return {
+      checkId: check.id,
+      passed: false,
+      message: "No ADRs found in docs/architecture/ADR/ (excluding template)",
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  if (result.invalid.length > 0) {
+    return {
+      checkId: check.id,
+      passed: false,
+      message: `${result.valid}/${result.count} ADRs valid \u2014 invalid: ${result.invalid.join(", ")}`,
+      checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  return {
+    checkId: check.id,
+    passed: true,
+    message: `${result.count} ADR(s) validated (Status, Context, Decision, Consequences)`,
+    checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function runGate(projectRoot, state, roundId) {
+  const round = ROUNDS.find((r) => r.id === roundId);
+  if (!round) {
+    throw new Error(`Round ${roundId} not found`);
+  }
+  const details = /* @__PURE__ */ new Map();
+  const results = round.gateChecks.map((check) => {
+    switch (check.type) {
+      case "file_exists":
+        return checkFileExists(projectRoot, check);
+      case "file_has_sections":
+        return checkFileSections(projectRoot, check);
+      case "min_count":
+        return checkMinCount(projectRoot, check);
+      case "human_approval":
+        return checkHumanApproval(state, roundId, check);
+      case "content_validated":
+        return checkContentValidated(projectRoot, check, details);
+      case "adr_validated":
+        return checkADRValidated(projectRoot, check, details);
+      case "custom":
+        return {
+          checkId: check.id,
+          passed: false,
+          message: "Custom gate \u2014 not yet implemented",
+          checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+    }
+  });
+  const allPassed = results.every((r) => r.passed);
+  const roundState = state.rounds[String(roundId)];
+  if (roundState) {
+    roundState.gateResults = results;
+    roundState.gate = allPassed ? "passed" : "failed";
+  }
+  return { roundId, allPassed, results, details };
+}
+
+// src/templates.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
+import { join as join4, dirname } from "path";
+function tpl(projectName) {
+  return [
+    {
+      path: "docs/product/PRD.md",
+      content: `# PRD \u2014 ${projectName}
+
+> Generated by BASTARD. Fill every section before passing the Round 1 gate.
+
+## Problem
+
+What problem are we solving? Who has this problem? How painful is it?
+
+## Users
+
+Who are the target users? Be specific \u2014 "everyone" is not a user.
+
+### Primary user
+
+### Secondary user (if applicable)
+
+## User Stories
+
+Format: As a [user type], I want [goal] so that [benefit].
+
+### Core stories (must-have)
+
+1.
+
+### Nice-to-have stories
+
+1.
+
+## Jobs to be Done
+
+What job is the user hiring this product to do?
+
+## Competitive Landscape
+
+What exists today? Why is it insufficient?
+
+## Solution Overview
+
+High-level description of what we're building.
+
+## Success Metrics
+
+How do we know this product is working?
+
+| Metric | Target | How we measure |
+|--------|--------|----------------|
+|        |        |                |
+
+## Scope
+
+### In scope (v1)
+
+### Out of scope (v1, future consideration)
+
+## Open Questions
+
+1.
+`
+    },
+    {
+      path: "docs/product/PERSONAS.md",
+      content: `# Personas \u2014 ${projectName}
+
+> Generated by BASTARD. Define at least 2 personas before passing the Round 1 gate.
+
+## Persona 1: [Name]
+
+- **Role:**
+- **Age range:**
+- **Tech savviness:** Low / Medium / High
+- **Goals:**
+- **Pain points:**
+- **Quote:** "[Something they would actually say]"
+
+### Typical day
+
+### How they discover us
+
+### What makes them stay
+
+### What makes them leave
+
+---
+
+## Persona 2: [Name]
+
+- **Role:**
+- **Age range:**
+- **Tech savviness:** Low / Medium / High
+- **Goals:**
+- **Pain points:**
+- **Quote:** "[Something they would actually say]"
+
+### Typical day
+
+### How they discover us
+
+### What makes them stay
+
+### What makes them leave
+`
+    },
+    {
+      path: "docs/product/ACCEPTANCE_CRITERIA.md",
+      content: `# Acceptance Criteria \u2014 ${projectName}
+
+> Generated by BASTARD. These criteria are verified in Round 8 by the acceptance-checker agent.
+> A criterion is either GREEN (met) or RED (not met). No partial credit.
+
+## Format
+
+\`\`\`
+AC-XXX: [Short title]
+Given [precondition]
+When [action]
+Then [expected result]
+Priority: MUST | SHOULD | COULD
+\`\`\`
+
+## Core Criteria
+
+### AC-001: [Title]
+Given ...
+When ...
+Then ...
+Priority: MUST
+
+### AC-002: [Title]
+Given ...
+When ...
+Then ...
+Priority: MUST
+
+## Secondary Criteria
+
+### AC-100: [Title]
+Given ...
+When ...
+Then ...
+Priority: SHOULD
+`
+    },
+    {
+      path: "docs/design/DESIGN.md",
+      content: `# Design System \u2014 ${projectName}
+
+> Generated by BASTARD. Define tokens before writing any CSS (Round 2 gate).
+
+## Brand Identity
+
+### Personality
+-
+### Tone
+-
+
+## Color
+
+### Primary palette
+
+| Token | Value | Usage |
+|-------|-------|-------|
+| \`--color-primary\` | | Main actions, links |
+| \`--color-primary-hover\` | | Hover states |
+| \`--color-secondary\` | | Secondary actions |
+
+### Neutral palette
+
+| Token | Value | Usage |
+|-------|-------|-------|
+| \`--color-bg\` | | Page background |
+| \`--color-surface\` | | Card/panel background |
+| \`--color-text\` | | Body text |
+| \`--color-text-muted\` | | Secondary text |
+| \`--color-border\` | | Borders, dividers |
+
+### Semantic palette
+
+| Token | Value | Usage |
+|-------|-------|-------|
+| \`--color-success\` | | Success states |
+| \`--color-warning\` | | Warning states |
+| \`--color-error\` | | Error states |
+| \`--color-info\` | | Info states |
+
+## Typography
+
+### Font families
+
+| Token | Value | Usage |
+|-------|-------|-------|
+| \`--font-heading\` | | Headings |
+| \`--font-body\` | | Body text |
+| \`--font-mono\` | | Code, technical |
+
+### Type scale
+
+| Token | Size | Line height | Weight | Usage |
+|-------|------|-------------|--------|-------|
+| \`--text-xs\` | | | | Captions |
+| \`--text-sm\` | | | | Small text |
+| \`--text-base\` | | | | Body |
+| \`--text-lg\` | | | | Large body |
+| \`--text-xl\` | | | | H4 |
+| \`--text-2xl\` | | | | H3 |
+| \`--text-3xl\` | | | | H2 |
+| \`--text-4xl\` | | | | H1 |
+
+## Spacing
+
+| Token | Value |
+|-------|-------|
+| \`--space-1\` | 4px |
+| \`--space-2\` | 8px |
+| \`--space-3\` | 12px |
+| \`--space-4\` | 16px |
+| \`--space-6\` | 24px |
+| \`--space-8\` | 32px |
+| \`--space-12\` | 48px |
+| \`--space-16\` | 64px |
+
+## Border Radius
+
+| Token | Value | Usage |
+|-------|-------|-------|
+| \`--radius-sm\` | | Buttons, inputs |
+| \`--radius-md\` | | Cards |
+| \`--radius-lg\` | | Modals, panels |
+| \`--radius-full\` | 9999px | Avatars, pills |
+
+## Shadows
+
+| Token | Value | Usage |
+|-------|-------|-------|
+| \`--shadow-sm\` | | Subtle elevation |
+| \`--shadow-md\` | | Cards |
+| \`--shadow-lg\` | | Modals, dropdowns |
+
+## Component Patterns
+
+### Buttons
+### Cards
+### Forms
+### Navigation
+`
+    },
+    {
+      path: "docs/architecture/ARCHITECTURE.md",
+      content: `# Architecture \u2014 ${projectName}
+
+> Generated by BASTARD. Document all major decisions here with corresponding ADRs (Round 3 gate).
+
+## System Overview
+
+High-level architecture diagram (ASCII or link to diagram).
+
+## Stack
+
+| Layer | Technology | Rationale |
+|-------|-----------|-----------|
+| Frontend | | |
+| API | | |
+| Database | | |
+| Auth | | |
+| Hosting | | |
+
+## Data Model
+
+### Core entities
+
+### Relationships
+
+## API Design
+
+### Endpoints overview
+
+### Authentication flow
+
+## Infrastructure
+
+### Deployment topology
+
+### Environments
+
+| Env | Purpose | URL |
+|-----|---------|-----|
+| dev | | |
+| staging | | |
+| prod | | |
+
+## Security Architecture
+
+### Encryption at rest
+### Encryption in transit
+### Authentication
+### Authorization
+
+## ADRs
+
+See \`docs/architecture/ADR/\` for all architecture decision records.
+`
+    },
+    {
+      path: "docs/architecture/ADR/ADR-000-template.md",
+      content: `# ADR-000: Template
+
+> Copy this template for each new architecture decision.
+
+## Status
+
+Proposed
+
+## Date
+
+YYYY-MM-DD
+
+## Context
+
+Why is this decision necessary? What problem are we solving?
+What constraints exist?
+
+## Options Considered
+
+### Option A: [Name]
+- **Pros:** ...
+- **Cons:** ...
+
+### Option B: [Name]
+- **Pros:** ...
+- **Cons:** ...
+
+## Decision
+
+What we chose and why.
+
+## Consequences
+
+### Positive
+-
+
+### Negative
+-
+
+### Risks
+-
+`
+    },
+    {
+      path: "docs/security/THREAT_MODEL.md",
+      content: `# Threat Model \u2014 ${projectName}
+
+> Generated by BASTARD. STRIDE analysis required before Round 6 gate.
+
+## Assets
+
+What are we protecting?
+
+| Asset | Sensitivity | Impact if compromised |
+|-------|------------|----------------------|
+| | | |
+
+## STRIDE Analysis
+
+### Spoofing
+
+### Tampering
+
+### Repudiation
+
+### Information Disclosure
+
+### Denial of Service
+
+### Elevation of Privilege
+
+## Attack Surface
+
+### External
+### Internal
+
+## Mitigations
+
+| Threat | Mitigation | Status |
+|--------|-----------|--------|
+| | | |
+
+## Risk Matrix
+
+| Risk | Likelihood | Impact | DREAD Score | Priority |
+|------|-----------|--------|-------------|----------|
+| | | | | |
+`
+    },
+    {
+      path: "docs/security/SECURITY_REVIEW.md",
+      content: `# Security Review \u2014 ${projectName}
+
+> Generated by BASTARD. Completed by the security-reviewer agent.
+
+## Review Date
+
+YYYY-MM-DD
+
+## Scope
+
+What was reviewed?
+
+## OWASP Top 10 Checklist
+
+| # | Category | Status | Notes |
+|---|----------|--------|-------|
+| 1 | Injection | | |
+| 2 | Broken Authentication | | |
+| 3 | Sensitive Data Exposure | | |
+| 4 | XML External Entities | | |
+| 5 | Broken Access Control | | |
+| 6 | Security Misconfiguration | | |
+| 7 | XSS | | |
+| 8 | Insecure Deserialization | | |
+| 9 | Known Vulnerabilities | | |
+| 10 | Insufficient Logging | | |
+
+## Findings
+
+### Critical
+
+### High
+
+### Medium
+
+### Low
+
+## Recommendations
+
+## Sign-off
+
+- [ ] 0 Critical findings
+- [ ] 0 High findings
+- [ ] All Medium findings have mitigation plan
+`
+    },
+    {
+      path: "docs/planning/CONTEXT.md",
+      content: `# Context \u2014 ${projectName}
+
+> Generated by BASTARD. Filled during Round 4 to capture all ambiguities resolved.
+
+## Decisions Made
+
+| # | Question | Decision | Rationale |
+|---|----------|----------|-----------|
+| 1 | | | |
+
+## Assumptions
+
+| # | Assumption | Risk if wrong | Validation plan |
+|---|-----------|---------------|-----------------|
+| 1 | | | |
+
+## Dependencies
+
+| # | Dependency | Owner | Status | Blocker? |
+|---|-----------|-------|--------|----------|
+| 1 | | | | |
+
+## Wave Plan
+
+### Wave 1 (Sequential \u2014 blocking)
+
+### Wave 2 (Parallel \u2014 independent)
+
+### Wave 3 (Parallel \u2014 independent)
+`
+    }
+  ];
+}
+function scaffoldTemplates(projectRoot, projectName) {
+  const templates = tpl(projectName);
+  const created = [];
+  for (const template of templates) {
+    const fullPath = join4(projectRoot, template.path);
+    if (existsSync4(fullPath)) {
+      continue;
+    }
+    const dir = dirname(fullPath);
+    if (!existsSync4(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    writeFileSync2(fullPath, template.content);
+    created.push(template.path);
+  }
+  return created;
+}
+
+// src/guard.ts
+import { execSync } from "child_process";
+import { resolve } from "path";
+function isSourceCode(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  if (/\/(src|lib|app|components|pages|api|services|utils|hooks|stores)\//i.test(normalized)) return true;
+  if (/\.(ts|tsx|js|jsx|py|go|rs|java|rb|php|swift|kt)$/i.test(normalized) && !/\/docs\//.test(normalized)) return true;
+  return false;
+}
+function isTestCode(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  if (/\/(tests?|__tests__|spec|e2e|cypress)\//i.test(normalized)) return true;
+  if (/\.(test|spec)\.(ts|tsx|js|jsx)$/i.test(normalized)) return true;
+  return false;
+}
+function isStyling(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return /\.(css|scss|sass|less|styl|styled\.(ts|js))$/i.test(normalized) || /tailwind\.config/i.test(normalized);
+}
+function isTaskFile(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return /\/(tasks|\.planning)\//i.test(normalized);
+}
+function isSecuritySensitive(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  return /\/(auth|session|token|password|crypto|encrypt|payment|billing|checkout)\//i.test(normalized) || /\/(auth|session|token|password|crypto|encrypt|payment|billing|checkout)\.(ts|js|tsx|jsx)/i.test(normalized) || /middleware\.(ts|js)/i.test(normalized);
+}
+function evaluateGuard(projectRoot, tool) {
+  if (!stateExists(projectRoot)) {
+    return { allowed: true, reason: "No BASTARD project \u2014 guard inactive" };
+  }
+  const state = loadState(projectRoot);
+  const round = state.currentRound;
+  const toolName = tool.tool_name;
+  const filePath = tool.tool_input.file_path ?? "";
+  if (!["Write", "Edit", "NotebookEdit"].includes(toolName)) {
+    return { allowed: true, reason: "Non-writing tool \u2014 allowed" };
+  }
+  const absPath = filePath.startsWith("/") ? filePath : resolve(projectRoot, filePath);
+  const relPath = absPath.replace(projectRoot + "/", "");
+  if (relPath.startsWith("docs/") || relPath.startsWith(".bastard/")) {
+    return { allowed: true, reason: "Documentation/state write \u2014 always allowed" };
+  }
+  if (/^(CLAUDE|README|CONTRIBUTING|LICENSE|CHANGELOG)/i.test(relPath)) {
+    return { allowed: true, reason: "Project root file \u2014 allowed" };
+  }
+  if (round < 5 && isSourceCode(relPath)) {
+    return {
+      allowed: false,
+      reason: `BASTARD: No source code before Round 5 (currently Round ${round}). Complete Rounds 1-4 first: product vision \u2192 design \u2192 architecture \u2192 planning.`
+    };
+  }
+  if (round < 5 && isTestCode(relPath)) {
+    return {
+      allowed: false,
+      reason: `BASTARD: No test code before Round 5 (currently Round ${round}).`
+    };
+  }
+  if (isStyling(relPath)) {
+    const round2 = state.rounds["2"];
+    if (!round2 || round2.gate !== "passed") {
+      return {
+        allowed: false,
+        reason: `BASTARD: No CSS/styling before Round 2 gate passes. Approve the design system first: bastard approve 2`
+      };
+    }
+  }
+  if (round < 4 && isTaskFile(relPath)) {
+    return {
+      allowed: false,
+      reason: `BASTARD: No task/planning files before Round 4 (currently Round ${round}).`
+    };
+  }
+  if (isSecuritySensitive(relPath)) {
+    const round6 = state.rounds["6"];
+    if (round < 6 || !round6 || round6.gate !== "passed") {
+      if (round > 5 && (!round6 || round6.gate !== "passed")) {
+        return {
+          allowed: false,
+          reason: `BASTARD: Security-sensitive file detected. Complete Round 6 (security review) first.`
+        };
+      }
+    }
+  }
+  return { allowed: true, reason: "Allowed by guard rules" };
+}
+function evaluateBashGuard(projectRoot, tool) {
+  if (!stateExists(projectRoot)) {
+    return { allowed: true, reason: "No BASTARD project \u2014 guard inactive" };
+  }
+  if (tool.tool_name !== "Bash") {
+    return { allowed: true, reason: "Not a bash command" };
+  }
+  const command = tool.tool_input.command ?? "";
+  const state = loadState(projectRoot);
+  const round = state.currentRound;
+  if (/git\s+add\s+(-A|\.)\s*$/.test(command)) {
+    return {
+      allowed: false,
+      reason: "BASTARD: `git add .` and `git add -A` are forbidden. Stage files individually."
+    };
+  }
+  if (/git\s+commit/.test(command) && !/-b\s/.test(command)) {
+    try {
+      const branch = execSync("git branch --show-current", { cwd: projectRoot, encoding: "utf-8" }).trim();
+      if (branch === "main" || branch === "master") {
+        return {
+          allowed: false,
+          reason: "BASTARD: No direct commits to main/master. Create a feature branch first."
+        };
+      }
+    } catch {
+    }
+  }
+  return { allowed: true, reason: "Bash command allowed" };
+}
+function guard(projectRoot, input) {
+  let tool;
+  try {
+    tool = JSON.parse(input);
+  } catch {
+    return { allowed: true, reason: "Could not parse input \u2014 allowing" };
+  }
+  const writeResult = evaluateGuard(projectRoot, tool);
+  if (!writeResult.allowed) return writeResult;
+  const bashResult = evaluateBashGuard(projectRoot, tool);
+  if (!bashResult.allowed) return bashResult;
+  return { allowed: true, reason: "All guards passed" };
+}
+async function runGuardFromStdin(projectRoot) {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  const input = Buffer.concat(chunks).toString("utf-8");
+  const result = guard(projectRoot, input);
+  if (!result.allowed) {
+    process.stderr.write(result.reason + "\n");
+    process.exit(2);
+  }
+  process.exit(0);
+}
+
+// src/hooks.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join5, resolve as resolve2 } from "path";
+function generateHooksConfig(projectRoot) {
+  const bastardCli = resolve2(projectRoot, "node_modules/.bin/bastard");
+  const fallbackCli = resolve2(projectRoot, "dist/cli.js");
+  let cmd;
+  if (existsSync5(bastardCli)) {
+    cmd = bastardCli;
+  } else if (existsSync5(fallbackCli)) {
+    cmd = `node ${fallbackCli}`;
+  } else {
+    cmd = "npx bastard-framework";
+  }
+  return {
+    hooks: {
+      PreToolUse: [
+        {
+          matcher: "Write|Edit|NotebookEdit",
+          command: `${cmd} guard`
+        },
+        {
+          matcher: "Bash",
+          command: `${cmd} guard`
+        }
+      ]
+    }
+  };
+}
+function installHooks(projectRoot) {
+  const claudeDir = join5(projectRoot, ".claude");
+  const settingsPath = join5(claudeDir, "settings.local.json");
+  if (!existsSync5(claudeDir)) {
+    mkdirSync3(claudeDir, { recursive: true });
+  }
+  const config = generateHooksConfig(projectRoot);
+  let merged = false;
+  if (existsSync5(settingsPath)) {
+    try {
+      const existing = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+      if (!existing.hooks) existing.hooks = {};
+      if (!existing.hooks.PreToolUse) existing.hooks.PreToolUse = [];
+      existing.hooks.PreToolUse = existing.hooks.PreToolUse.filter(
+        (h) => !h.command.includes("bastard")
+      );
+      existing.hooks.PreToolUse.push(...config.hooks.PreToolUse);
+      writeFileSync3(settingsPath, JSON.stringify(existing, null, 2) + "\n");
+      merged = true;
+      return { created: false, path: settingsPath, merged: true };
+    } catch {
+    }
+  }
+  writeFileSync3(settingsPath, JSON.stringify(config, null, 2) + "\n");
+  return { created: true, path: settingsPath, merged: false };
+}
+function removeHooks(projectRoot) {
+  const settingsPath = join5(projectRoot, ".claude", "settings.local.json");
+  if (!existsSync5(settingsPath)) return false;
+  try {
+    const existing = JSON.parse(readFileSync4(settingsPath, "utf-8"));
+    if (existing.hooks?.PreToolUse) {
+      existing.hooks.PreToolUse = existing.hooks.PreToolUse.filter(
+        (h) => !h.command.includes("bastard")
+      );
+      if (existing.hooks.PreToolUse.length === 0) {
+        delete existing.hooks.PreToolUse;
+      }
+      if (Object.keys(existing.hooks).length === 0) {
+        delete existing.hooks;
+      }
+    }
+    writeFileSync3(settingsPath, JSON.stringify(existing, null, 2) + "\n");
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/parents.ts
+import { existsSync as existsSync6 } from "fs";
+import { join as join6 } from "path";
+import { execSync as execSync2 } from "child_process";
+var PARENTS = [
+  {
+    id: "bmad",
+    name: "BMAD Method",
+    role: "Vision produit, PRD, Architecture",
+    rounds: [1, 3],
+    installCmd: "npx bmad-method install",
+    detectors: [
+      { type: "dir", value: ".bmad" },
+      { type: "npm", value: "bmad-method" },
+      { type: "file", value: ".claude/agents/bmad-analyst.md" },
+      { type: "file", value: ".claude/agents/bmad-pm.md" }
+    ]
+  },
+  {
+    id: "gsd",
+    name: "Get Shit Done",
+    role: "Context engineering, wave execution",
+    rounds: [4, 5, 8],
+    installCmd: "npx gsd@latest install",
+    detectors: [
+      { type: "dir", value: ".gsd" },
+      { type: "npm", value: "gsd" },
+      { type: "file", value: ".gsd/config.json" }
+    ]
+  },
+  {
+    id: "gstack",
+    name: "gstack",
+    role: "Design system, QA browser, livraison",
+    rounds: [2, 7, 8],
+    installCmd: "git clone https://github.com/garrytan/gstack .gstack && cd .gstack && ./install.sh",
+    detectors: [
+      { type: "dir", value: ".gstack" },
+      { type: "file", value: ".claude/skills/design-consultation.md" },
+      { type: "file", value: ".claude/skills/qa.md" }
+    ]
+  },
+  {
+    id: "super",
+    name: "SuperClaude",
+    role: "Cognitive personas, token efficiency",
+    rounds: [3, 5, 6],
+    installCmd: "git clone https://github.com/superclaude/superclaude .superclaude && cd .superclaude && ./install.sh",
+    detectors: [
+      { type: "dir", value: ".superclaude" },
+      { type: "file", value: ".claude/personas" }
+    ]
+  },
+  {
+    id: "tob",
+    name: "Trail of Bits",
+    role: "Security review, threat modeling",
+    rounds: [6],
+    installCmd: "npx skills add trailofbits/skills",
+    detectors: [
+      { type: "file", value: ".claude/skills/security-review.md" },
+      { type: "file", value: ".claude/skills/threat-modeling.md" }
+    ]
+  },
+  {
+    id: "turbo",
+    name: "TurboDocx FD",
+    role: "Frontend design anti-AI-slop",
+    rounds: [2],
+    installCmd: "npx skills add turbodocx/frontend-design",
+    detectors: [
+      { type: "file", value: ".claude/skills/frontend-design.md" }
+    ]
+  },
+  {
+    id: "taskm",
+    name: "TaskMaster",
+    role: "Task decomposition, dependency graph",
+    rounds: [4],
+    installCmd: "npx task-master-ai@latest init",
+    detectors: [
+      { type: "npm", value: "task-master-ai" },
+      { type: "command", value: "task-master" },
+      { type: "file", value: "tasks/tasks.json" }
+    ]
+  }
+];
+function detect(projectRoot, detector) {
+  switch (detector.type) {
+    case "dir":
+      return existsSync6(join6(projectRoot, detector.value));
+    case "file":
+      return existsSync6(join6(projectRoot, detector.value));
+    case "npm":
+      return existsSync6(join6(projectRoot, "node_modules", detector.value));
+    case "command":
+      try {
+        execSync2(`which ${detector.value}`, { stdio: "ignore" });
+        return true;
+      } catch {
+        return false;
+      }
+    case "glob":
+      return existsSync6(join6(projectRoot, detector.value));
+  }
+}
+function detectParents(projectRoot) {
+  return PARENTS.map((framework) => {
+    for (const detector of framework.detectors) {
+      if (detect(projectRoot, detector)) {
+        return {
+          framework,
+          installed: true,
+          detectedVia: `${detector.type}: ${detector.value}`
+        };
+      }
+    }
+    return {
+      framework,
+      installed: false,
+      detectedVia: null
+    };
+  });
+}
+
+// src/installer.ts
+import { execSync as execSync3, spawn } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import { join as join7 } from "path";
+function getInstallSpecs(projectRoot) {
+  return [
+    {
+      framework: PARENTS.find((p) => p.id === "bmad"),
+      method: "npm",
+      command: "npx bmad-method@latest install"
+    },
+    {
+      framework: PARENTS.find((p) => p.id === "gsd"),
+      method: "npm",
+      command: "npx gsd@latest install"
+    },
+    {
+      framework: PARENTS.find((p) => p.id === "gstack"),
+      method: "git",
+      command: "git clone --depth 1 https://github.com/garrytan/gstack.git .gstack"
+    },
+    {
+      framework: PARENTS.find((p) => p.id === "super"),
+      method: "git",
+      command: "git clone --depth 1 https://github.com/superclaude/superclaude.git .superclaude"
+    },
+    {
+      framework: PARENTS.find((p) => p.id === "tob"),
+      method: "skill",
+      command: "npx @anthropic-ai/claude-code-skills@latest add trailofbits/skills"
+    },
+    {
+      framework: PARENTS.find((p) => p.id === "turbo"),
+      method: "skill",
+      command: "npx @anthropic-ai/claude-code-skills@latest add turbodocx/frontend-design"
+    },
+    {
+      framework: PARENTS.find((p) => p.id === "taskm"),
+      method: "npm",
+      command: "npx task-master-ai@latest init"
+    }
+  ];
+}
+function runCommand(command, cwd) {
+  return new Promise((resolve4) => {
+    const parts = command.split(" ");
+    const proc = spawn(parts[0], parts.slice(1), {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      shell: true,
+      env: { ...process.env, FORCE_COLOR: "0" }
+    });
+    let output = "";
+    proc.stdout?.on("data", (d) => {
+      output += d.toString();
+    });
+    proc.stderr?.on("data", (d) => {
+      output += d.toString();
+    });
+    proc.on("close", (code) => {
+      resolve4({ ok: code === 0, output });
+    });
+    proc.on("error", (err) => {
+      resolve4({ ok: false, output: err.message });
+    });
+    setTimeout(() => {
+      proc.kill("SIGTERM");
+      resolve4({ ok: false, output: "Install timed out after 120s" });
+    }, 12e4);
+  });
+}
+async function installOne(spec, projectRoot, force, status) {
+  const start = Date.now();
+  const fw = spec.framework;
+  if (status.installed && !force) {
+    return {
+      frameworkId: fw.id,
+      name: fw.name,
+      success: true,
+      alreadyInstalled: true,
+      updated: false,
+      duration: 0
+    };
+  }
+  if (spec.method === "git" && status.installed && force) {
+    const repoDir = spec.command.split(" ").pop();
+    const pullCmd = `git -C ${repoDir} pull --ff-only`;
+    const result2 = await runCommand(pullCmd, projectRoot);
+    return {
+      frameworkId: fw.id,
+      name: fw.name,
+      success: result2.ok,
+      alreadyInstalled: false,
+      updated: true,
+      error: result2.ok ? void 0 : result2.output.slice(0, 200),
+      duration: Date.now() - start
+    };
+  }
+  if (spec.method === "git" && force) {
+    const repoDir = join7(projectRoot, spec.command.split(" ").pop());
+    if (existsSync7(repoDir)) {
+      execSync3(`rm -rf ${repoDir}`, { cwd: projectRoot });
+    }
+  }
+  const result = await runCommand(spec.command, projectRoot);
+  return {
+    frameworkId: fw.id,
+    name: fw.name,
+    success: result.ok,
+    alreadyInstalled: false,
+    updated: false,
+    error: result.ok ? void 0 : result.output.slice(0, 200),
+    duration: Date.now() - start
+  };
+}
+async function installParents(projectRoot, opts = {}, onProgress) {
+  const specs = getInstallSpecs(projectRoot);
+  const statuses = detectParents(projectRoot);
+  const statusMap = new Map(statuses.map((s) => [s.framework.id, s]));
+  let filtered = specs;
+  if (opts.only && opts.only.length > 0) {
+    filtered = specs.filter((s) => opts.only.includes(s.framework.id));
+  }
+  if (opts.skip && opts.skip.length > 0) {
+    filtered = filtered.filter((s) => !opts.skip.includes(s.framework.id));
+  }
+  const results = [];
+  for (let i = 0; i < filtered.length; i++) {
+    const spec = filtered[i];
+    const status = statusMap.get(spec.framework.id);
+    const result = await installOne(spec, projectRoot, opts.force ?? false, status);
+    results.push(result);
+    onProgress?.(result, i + 1, filtered.length);
+  }
+  return results;
+}
+
+// src/orchestrator.ts
+var WORKFLOWS = [
+  {
+    roundId: 1,
+    name: "Vision & Product",
+    steps: [
+      {
+        id: "r1-analysis",
+        framework: "bmad",
+        action: '/bmad-analyst "Describe your product idea"',
+        description: "Product analysis \u2014 personas, pain points, jobs-to-be-done",
+        output: "Initial brief",
+        fallbackAction: "Manually write the product brief focusing on: target users, their pain points, and what job the product does for them."
+      },
+      {
+        id: "r1-prd",
+        framework: "bmad",
+        action: "/bmad-pm",
+        description: "Generate structured PRD with user stories and acceptance criteria",
+        output: "docs/product/PRD.md",
+        fallbackAction: "Fill docs/product/PRD.md template \u2014 every section must have real content (not just placeholders)."
+      },
+      {
+        id: "r1-personas",
+        framework: "bmad",
+        action: "Fill docs/product/PERSONAS.md",
+        description: "Define at least 2 detailed user personas",
+        output: "docs/product/PERSONAS.md",
+        isManual: true
+      },
+      {
+        id: "r1-acceptance",
+        framework: "bmad",
+        action: "Fill docs/product/ACCEPTANCE_CRITERIA.md",
+        description: "Write acceptance criteria in AC-XXX Given/When/Then format",
+        output: "docs/product/ACCEPTANCE_CRITERIA.md",
+        isManual: true
+      }
+    ],
+    contextAdvice: "Round 1 is deep thinking. Use Opus 4.6 for best results.",
+    completionSteps: [
+      "bastard validate prd",
+      "bastard gate",
+      "bastard approve 1",
+      "bastard next"
+    ]
+  },
+  {
+    roundId: 2,
+    name: "Design System & UX",
+    steps: [
+      {
+        id: "r2-consultation",
+        framework: "gstack",
+        action: "/design-consultation",
+        description: "Design system from scratch \u2014 brand identity, tokens, scale",
+        output: "docs/design/DESIGN.md",
+        fallbackAction: "Fill docs/design/DESIGN.md with concrete values for every token (colors, typography, spacing). No empty cells."
+      },
+      {
+        id: "r2-shotgun",
+        framework: "gstack",
+        action: "/design-shotgun",
+        description: "3 visual variants \u2192 interactive comparison board",
+        output: "docs/design/mockups/",
+        fallbackAction: "Create 3 distinct visual directions (mood boards or quick mockups). Choose one."
+      },
+      {
+        id: "r2-antiSlop",
+        framework: "turbo",
+        action: "/frontend-design with 4 dimensions: purpose, tone, constraints, differentiation",
+        description: "Anti-AI-slop design review \u2014 kills generic layouts",
+        fallbackAction: "Self-review DESIGN.md against the AI Slop Blacklist: no 3-column icon grids, no blue-purple gradients, no single font, no stock photo heroes."
+      }
+    ],
+    contextAdvice: "/clear before starting Round 2 (different creative mode than Round 1).",
+    completionSteps: [
+      "bastard validate design",
+      "bastard gate",
+      "bastard approve 2",
+      "bastard next"
+    ]
+  },
+  {
+    roundId: 3,
+    name: "Architecture",
+    steps: [
+      {
+        id: "r3-architect",
+        framework: "bmad",
+        action: "/bmad-architect",
+        description: "Architecture decisions \u2014 stack, infra schema, ADRs",
+        output: "docs/architecture/ARCHITECTURE.md",
+        fallbackAction: "Fill ARCHITECTURE.md with stack choices, data model, API design, infra topology."
+      },
+      {
+        id: "r3-tradeoffs",
+        framework: "super",
+        action: "--persona-architect to analyze trade-offs",
+        description: "Detect over-engineering, YAGNI violations, complexity budget",
+        fallbackAction: "Review each architectural decision: Is this the simplest thing that works? Would I regret this in 6 months?"
+      },
+      {
+        id: "r3-adrs",
+        framework: "bmad",
+        action: "Write ADRs for each major decision",
+        description: "One ADR per major decision \u2014 Status, Context, Options, Decision, Consequences",
+        output: "docs/architecture/ADR/ADR-001.md, ...",
+        isManual: true
+      }
+    ],
+    contextAdvice: "Use Opus 4.6 for architecture decisions. This round defines everything downstream.",
+    completionSteps: [
+      "bastard validate architecture",
+      "bastard gate",
+      "bastard approve 3",
+      "bastard next"
+    ]
+  },
+  {
+    roundId: 4,
+    name: "Decomposition & Planification",
+    steps: [
+      {
+        id: "r4-parse",
+        framework: "taskm",
+        action: "task-master parse-prd --input docs/product/PRD.md",
+        description: "Parse PRD + architecture into weighted task graph",
+        output: "tasks/",
+        fallbackAction: "Manually break the PRD into tasks. One task = one responsibility = one commit. No task > 2h."
+      },
+      {
+        id: "r4-analyze",
+        framework: "taskm",
+        action: "task-master analyze",
+        description: "Complexity scores, dependencies, execution order",
+        fallbackAction: "For each task: estimate complexity (1-5), list dependencies, assign to wave (blocking=Wave1, independent=Wave2+)."
+      },
+      {
+        id: "r4-discuss",
+        framework: "gsd",
+        action: "/gsd:discuss-phase",
+        description: "Kill all ambiguities before writing a single line of code",
+        output: "docs/planning/CONTEXT.md",
+        fallbackAction: "Fill docs/planning/CONTEXT.md with every decision made, assumption identified, and dependency tracked."
+      },
+      {
+        id: "r4-plan",
+        framework: "gsd",
+        action: "/gsd:plan-phase",
+        description: "Detailed execution plans organized by wave",
+        output: ".planning/phases/",
+        fallbackAction: "Create wave-based plan: Wave 1 (sequential blockers), Wave 2+ (parallelizable independent tasks)."
+      }
+    ],
+    contextAdvice: "Sonnet 4.6 is fast enough for decomposition. Save Opus for the thinking rounds.",
+    completionSteps: [
+      "bastard gate",
+      "bastard next"
+    ]
+  },
+  {
+    roundId: 5,
+    name: "Execution du Code",
+    steps: [
+      {
+        id: "r5-execute",
+        framework: "gsd",
+        action: "/gsd:execute-phase",
+        description: "Wave-based execution with sub-contexts and atomic commits",
+        output: "src/, tests/",
+        fallbackAction: "Execute tasks wave by wave. Each completed task = immediate commit with conventional message."
+      },
+      {
+        id: "r5-backend",
+        framework: "super",
+        action: "--persona-backend for APIs and business logic",
+        description: "Switch to backend persona for service layer code",
+        fallbackAction: "Focus: APIs, services, business logic. TypeScript strict, TDD, 80% coverage minimum."
+      },
+      {
+        id: "r5-frontend",
+        framework: "super",
+        action: "--persona-frontend for UI components",
+        description: "Switch to frontend persona for UI layer",
+        fallbackAction: "Focus: components, state management, routing. Use design tokens from DESIGN.md."
+      }
+    ],
+    contextAdvice: "/compact between phases. Context must stay under 40%. Use sub-agents for read-heavy tasks.",
+    completionSteps: [
+      "bastard gate",
+      "bastard next"
+    ]
+  },
+  {
+    roundId: 6,
+    name: "Securite",
+    steps: [
+      {
+        id: "r6-threat",
+        framework: "tob",
+        action: "/threat-modeling",
+        description: "STRIDE methodology \u2014 identify threats, DREAD/CVSS scoring",
+        output: "docs/security/THREAT_MODEL.md",
+        fallbackAction: "Fill THREAT_MODEL.md using STRIDE: Spoofing, Tampering, Repudiation, Info Disclosure, DoS, Elevation of Privilege."
+      },
+      {
+        id: "r6-review",
+        framework: "tob",
+        action: "/security-review",
+        description: "OWASP Top 10 code review, auth/crypto/input validation",
+        output: "docs/security/SECURITY_REVIEW.md",
+        fallbackAction: "Run through OWASP Top 10 checklist against codebase. Document findings with severity."
+      },
+      {
+        id: "r6-persona",
+        framework: "super",
+        action: "--persona-security on auth/sessions/tokens code",
+        description: "Deep review of security-sensitive code paths",
+        fallbackAction: "Manual review: parameterized queries? Input validation? Secrets in code? Auth != authz separation?"
+      }
+    ],
+    contextAdvice: "Use Opus 4.6 for security review. Missing a vulnerability here is catastrophic.",
+    completionSteps: [
+      "bastard validate threat_model",
+      "bastard validate security_review",
+      "bastard gate",
+      "bastard next"
+    ]
+  },
+  {
+    roundId: 7,
+    name: "QA & Tests",
+    steps: [
+      {
+        id: "r7-qa",
+        framework: "gstack",
+        action: "/qa",
+        description: "Analyze diff, test affected routes, generate regression tests",
+        fallbackAction: "Run full test suite. Add regression tests for any fixed bugs. Check E2E flows."
+      },
+      {
+        id: "r7-designReview",
+        framework: "gstack",
+        action: "/design-review [URL]",
+        description: "80-point visual audit \u2014 Design Score + AI Slop Score",
+        fallbackAction: "Manual audit: check every page against DESIGN.md tokens. Score: A-F for design quality and AI slop."
+      }
+    ],
+    contextAdvice: "Sonnet 4.6 for QA. Fast iteration on test fixes.",
+    completionSteps: [
+      "bastard gate",
+      "bastard approve 7",
+      "bastard next"
+    ]
+  },
+  {
+    roundId: 8,
+    name: "Review & Livraison",
+    steps: [
+      {
+        id: "r8-engReview",
+        framework: "gstack",
+        action: "/plan-eng-review",
+        description: "Architecture review \u2014 data flow, edge cases, failure modes",
+        fallbackAction: "Review: data flows correct? Edge cases handled? Failure modes graceful?"
+      },
+      {
+        id: "r8-review",
+        framework: "gstack",
+        action: "/review",
+        description: "Adversarial review \u2014 two independent AI perspectives",
+        fallbackAction: "Get a second opinion on the code. Review with fresh eyes."
+      },
+      {
+        id: "r8-ship",
+        framework: "gstack",
+        action: "/ship",
+        description: "Scope drift detection, sync main, full test suite, PR",
+        fallbackAction: "Check: did we build what the PRD asked for? Run full tests. Create PR."
+      },
+      {
+        id: "r8-verify",
+        framework: "gsd",
+        action: "/gsd:verify",
+        description: "Verify against ACCEPTANCE_CRITERIA.md from Round 1",
+        output: "Acceptance verification report",
+        fallbackAction: "Go through ACCEPTANCE_CRITERIA.md line by line. Each AC-XXX must be demonstrably met in code + tests."
+      }
+    ],
+    contextAdvice: "/clear before Round 8. Fresh context for final review.",
+    completionSteps: [
+      "bastard gate",
+      "bastard approve 8",
+      "bastard next"
+    ]
+  }
+];
+function getWorkflow(roundId) {
+  return WORKFLOWS.find((w) => w.roundId === roundId);
+}
+function generatePrompt(workflow, installedFrameworks) {
+  const lines = [];
+  lines.push(`# Round ${workflow.roundId} \u2014 ${workflow.name}`);
+  lines.push("");
+  lines.push(`> ${workflow.contextAdvice}`);
+  lines.push("");
+  lines.push("## Workflow");
+  lines.push("");
+  for (let i = 0; i < workflow.steps.length; i++) {
+    const step = workflow.steps[i];
+    const num = i + 1;
+    const installed = installedFrameworks.has(step.framework);
+    lines.push(`### Step ${num}: ${step.description}`);
+    lines.push("");
+    if (installed) {
+      lines.push(`**Command:** \`${step.action}\``);
+    } else if (step.fallbackAction) {
+      lines.push(`**Action (${step.framework} not installed):** ${step.fallbackAction}`);
+    }
+    if (step.output) {
+      lines.push(`**Expected output:** \`${step.output}\``);
+    }
+    lines.push("");
+  }
+  lines.push("## After completion");
+  lines.push("");
+  lines.push("Run these commands in order:");
+  lines.push("");
+  for (const cmd of workflow.completionSteps) {
+    lines.push(`\`\`\`bash`);
+    lines.push(cmd);
+    lines.push(`\`\`\``);
+  }
+  return lines.join("\n");
+}
+
+// src/slop.ts
+import { readFileSync as readFileSync5, readdirSync as readdirSync3, statSync, existsSync as existsSync8 } from "fs";
+import { join as join8, extname } from "path";
+function findLines(content, pattern) {
+  const results = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (pattern.test(lines[i])) {
+      results.push({ line: i + 1, excerpt: lines[i].trim().slice(0, 120) });
+    }
+  }
+  return results;
+}
+function findMultilinePattern(content, pattern) {
+  const results = [];
+  const matches = content.matchAll(new RegExp(pattern.source, pattern.flags + (pattern.flags.includes("g") ? "" : "g")));
+  for (const match of matches) {
+    if (match.index !== void 0) {
+      const beforeMatch = content.slice(0, match.index);
+      const line = beforeMatch.split("\n").length;
+      results.push({ line, excerpt: match[0].replace(/\n/g, " ").trim().slice(0, 120) });
+    }
+  }
+  return results;
+}
+var CSS_EXTENSIONS = [".css", ".scss", ".sass", ".less"];
+var JSX_EXTENSIONS = [".tsx", ".jsx", ".ts", ".js"];
+var ALL_UI = [...CSS_EXTENSIONS, ...JSX_EXTENSIONS];
+var PATTERNS = [
+  // ── CSS Patterns ──────────────────────────────────────────────────────────
+  {
+    id: "blue-purple-gradient",
+    name: "Blue-Purple Gradient",
+    description: "The #1 tell of AI-generated UI. Every AI loves this gradient.",
+    severity: "major",
+    fileTypes: ALL_UI,
+    detect(content, filePath) {
+      const pattern = /linear-gradient\s*\([^)]*(?:blue|purple|violet|indigo|#6366f1|#8b5cf6|#7c3aed|#4f46e5|#818cf8|#a78bfa|#6c63ff|#9333ea|from-(?:blue|purple|violet|indigo))/gi;
+      return findLines(content, pattern).map((m) => ({
+        patternId: this.id,
+        patternName: this.name,
+        severity: this.severity,
+        file: filePath,
+        ...m
+      }));
+    }
+  },
+  {
+    id: "gradient-text",
+    name: "Gradient Text",
+    description: "background-clip: text with gradients. Readability nightmare, AI favorite.",
+    severity: "minor",
+    fileTypes: ALL_UI,
+    detect(content, filePath) {
+      const pattern = /(?:background-clip:\s*text|-webkit-background-clip:\s*text|bg-clip-text|bg-gradient-to-.*text-transparent)/gi;
+      return findLines(content, pattern).map((m) => ({
+        patternId: this.id,
+        patternName: this.name,
+        severity: this.severity,
+        file: filePath,
+        ...m
+      }));
+    }
+  },
+  {
+    id: "hero-oversized",
+    name: "Oversized Hero Section",
+    description: "Hero > 80vh with overlay. Stock photo territory.",
+    severity: "minor",
+    fileTypes: ALL_UI,
+    detect(content, filePath) {
+      const pattern = /(?:min-h-screen|h-screen|height:\s*100vh|min-height:\s*(?:9[0-9]|100)vh)/gi;
+      const heroContext = /(?:hero|banner|landing|jumbotron)/i;
+      const results = findLines(content, pattern);
+      return results.filter((r) => {
+        const lines = content.split("\n");
+        const start = Math.max(0, r.line - 5);
+        const end = Math.min(lines.length, r.line + 5);
+        const context = lines.slice(start, end).join("\n");
+        return heroContext.test(context);
+      }).map((m) => ({
+        patternId: this.id,
+        patternName: this.name,
+        severity: this.severity,
+        file: filePath,
+        ...m
+      }));
+    }
+  },
+  {
+    id: "generic-card-grid",
+    name: "Generic Card Grid",
+    description: "Rounded cards with shadows in a 3-column grid. The AI default layout.",
+    severity: "major",
+    fileTypes: ALL_UI,
+    detect(content, filePath) {
+      const gridPattern = /(?:grid-cols-3|grid-template-columns:\s*repeat\(3)/gi;
+      const roundedShadow = /(?:rounded-(?:lg|xl|2xl).*shadow|shadow.*rounded-(?:lg|xl|2xl)|border-radius.*box-shadow|box-shadow.*border-radius)/gi;
+      const gridMatches = findLines(content, gridPattern);
+      const shadowMatches = findLines(content, roundedShadow);
+      if (gridMatches.length > 0 && shadowMatches.length > 0) {
+        return gridMatches.map((m) => ({
+          patternId: this.id,
+          patternName: this.name,
+          severity: this.severity,
+          file: filePath,
+          ...m
+        }));
+      }
+      return [];
+    }
+  },
+  // ── JSX/Component Patterns ────────────────────────────────────────────────
+  {
+    id: "icon-grid-3col",
+    name: "3-Column Icon Grid",
+    description: "Every AI landing page: 3 features with generic icons.",
+    severity: "major",
+    fileTypes: JSX_EXTENSIONS,
+    detect(content, filePath) {
+      const iconImport = /import\s*{[^}]*}\s*from\s*['"](?:lucide-react|@heroicons|react-icons)/i;
+      const threeCol = /(?:grid-cols-3|md:grid-cols-3|lg:grid-cols-3)/i;
+      if (iconImport.test(content) && threeCol.test(content)) {
+        const matches = findLines(content, threeCol);
+        return matches.map((m) => ({
+          patternId: this.id,
+          patternName: this.name,
+          severity: this.severity,
+          file: filePath,
+          ...m
+        }));
+      }
+      return [];
+    }
+  },
+  {
+    id: "generic-ctas",
+    name: "Generic CTAs Only",
+    description: '"Get Started" / "Learn More" \u2014 zero thought on conversion.',
+    severity: "minor",
+    fileTypes: JSX_EXTENSIONS,
+    detect(content, filePath) {
+      const genericCtas = /(?:>Get Started<|>Learn More<|>Sign Up Free<|>Start Free Trial<|>Get Started Now<|>Try for Free<)/gi;
+      const allMatches = findLines(content, genericCtas);
+      const uniqueCta = /(?:>(?!Get Started|Learn More|Sign Up|Start Free|Try for Free)[A-Z][^<]{3,30}<)/g;
+      if (allMatches.length > 0 && !uniqueCta.test(content)) {
+        return allMatches.map((m) => ({
+          patternId: this.id,
+          patternName: this.name,
+          severity: this.severity,
+          file: filePath,
+          ...m
+        }));
+      }
+      return [];
+    }
+  },
+  {
+    id: "generic-section-flow",
+    name: "Generic Section Flow",
+    description: "Hero \u2192 Features \u2192 Pricing \u2192 Testimonials \u2192 CTA \u2192 Footer. The AI playbook.",
+    severity: "minor",
+    fileTypes: JSX_EXTENSIONS,
+    detect(content, filePath) {
+      const sections = ["hero", "features", "pricing", "testimonial", "cta", "footer"];
+      const found = sections.filter((s) => new RegExp(`(?:\\b${s}\\b|<${s}|id=["']${s})`, "i").test(content));
+      if (found.length >= 4) {
+        return [{ line: 1, excerpt: `Generic section flow: ${found.join(" \u2192 ")}` }].map((m) => ({
+          patternId: this.id,
+          patternName: this.name,
+          severity: this.severity,
+          file: filePath,
+          ...m
+        }));
+      }
+      return [];
+    }
+  },
+  {
+    id: "floating-shapes",
+    name: "Floating Abstract Shapes",
+    description: "Decorative blobs/circles positioned absolutely. Meaningless visual noise.",
+    severity: "minor",
+    fileTypes: ALL_UI,
+    detect(content, filePath) {
+      const pattern = /(?:absolute\s+[^"'<>]{0,200}?(?:rounded-full|border-radius:\s*50%)[^"'<>]{0,100}?blur|blur-(?:2xl|3xl)[^"'<>]{0,200}?rounded-full)/gi;
+      return findMultilinePattern(content, pattern).map((m) => ({
+        patternId: this.id,
+        patternName: this.name,
+        severity: this.severity,
+        file: filePath,
+        ...m
+      }));
+    }
+  },
+  {
+    id: "single-font",
+    name: "Single Font Family",
+    description: "Real designers use typographic hierarchy. One font = no hierarchy.",
+    severity: "minor",
+    fileTypes: CSS_EXTENSIONS,
+    detect(content, filePath) {
+      const fontFamilies = /* @__PURE__ */ new Set();
+      const pattern = /font-family:\s*["']?([^"';,\n]+)/gi;
+      let match;
+      while ((match = pattern.exec(content)) !== null) {
+        const font = match[1].trim().toLowerCase();
+        if (font !== "inherit" && font !== "sans-serif" && font !== "serif" && font !== "monospace") {
+          fontFamilies.add(font);
+        }
+      }
+      const tailwindFonts = content.match(/font-(?:sans|serif|mono|heading|body|display)/g);
+      if (tailwindFonts) {
+        for (const f of tailwindFonts) fontFamilies.add(f);
+      }
+      if (fontFamilies.size === 1 && content.length > 500) {
+        return [{ line: 1, excerpt: `Only one font family: ${[...fontFamilies][0]}` }].map((m) => ({
+          patternId: this.id,
+          patternName: this.name,
+          severity: this.severity,
+          file: filePath,
+          ...m
+        }));
+      }
+      return [];
+    }
+  }
+];
+function scanFiles(dir, extensions) {
+  const results = [];
+  if (!existsSync8(dir)) return results;
+  function walk(current) {
+    const entries = readdirSync3(current);
+    for (const entry of entries) {
+      if (entry.startsWith(".") || entry === "node_modules" || entry === "dist" || entry === "build") continue;
+      const fullPath = join8(current, entry);
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        walk(fullPath);
+      } else if (extensions.includes(extname(entry).toLowerCase())) {
+        results.push(fullPath);
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+function runSlopScan(targetDir) {
+  const allExtensions = [...new Set(PATTERNS.flatMap((p) => p.fileTypes))];
+  const files = scanFiles(targetDir, allExtensions);
+  const allMatches = [];
+  for (const file of files) {
+    const content = readFileSync5(file, "utf-8");
+    const ext = extname(file).toLowerCase();
+    for (const pattern of PATTERNS) {
+      if (!pattern.fileTypes.includes(ext)) continue;
+      const matches = pattern.detect(content, file.replace(targetDir + "/", ""));
+      allMatches.push(...matches);
+    }
+  }
+  const summary = {};
+  for (const m of allMatches) {
+    summary[m.patternName] = (summary[m.patternName] ?? 0) + 1;
+  }
+  const majorCount = allMatches.filter((m) => m.severity === "major").length;
+  const minorCount = allMatches.filter((m) => m.severity === "minor").length;
+  const totalScore = majorCount * 3 + minorCount;
+  let score;
+  if (totalScore === 0) score = "A";
+  else if (totalScore <= 2 && majorCount === 0) score = "B";
+  else if (totalScore <= 5 && majorCount <= 1) score = "C";
+  else if (totalScore <= 10) score = "D";
+  else score = "F";
+  return {
+    score,
+    totalFiles: files.length,
+    scannedFiles: files.length,
+    matches: allMatches,
+    summary
+  };
+}
+
+// src/design-score.ts
+import { readFileSync as readFileSync6, existsSync as existsSync9, readdirSync as readdirSync4, statSync as statSync2 } from "fs";
+import { join as join9, extname as extname2 } from "path";
+function extractTokensFromDesign(projectRoot) {
+  const designPath = join9(projectRoot, "docs/design/DESIGN.md");
+  const tokens = { colors: [], typography: [], spacing: [], radii: [], shadows: [] };
+  if (!existsSync9(designPath)) return tokens;
+  const content = readFileSync6(designPath, "utf-8");
+  const customProps = content.matchAll(/`(--[\w-]+)`/g);
+  for (const match of customProps) {
+    const prop = match[1];
+    if (prop.startsWith("--color-")) tokens.colors.push(prop);
+    else if (prop.startsWith("--font-") || prop.startsWith("--text-")) tokens.typography.push(prop);
+    else if (prop.startsWith("--space-")) tokens.spacing.push(prop);
+    else if (prop.startsWith("--radius-")) tokens.radii.push(prop);
+    else if (prop.startsWith("--shadow-")) tokens.shadows.push(prop);
+  }
+  return tokens;
+}
+function extractTokensFromCSS(projectRoot) {
+  const tokens = { colors: [], typography: [], spacing: [], radii: [], shadows: [] };
+  const cssFiles = scanFiles2(projectRoot, [".css", ".scss"]);
+  for (const file of cssFiles) {
+    const content = readFileSync6(file, "utf-8");
+    const customProps = content.matchAll(/(--[\w-]+)\s*:/g);
+    for (const match of customProps) {
+      const prop = match[1];
+      if (prop.startsWith("--color-") && !tokens.colors.includes(prop)) tokens.colors.push(prop);
+      else if ((prop.startsWith("--font-") || prop.startsWith("--text-")) && !tokens.typography.includes(prop)) tokens.typography.push(prop);
+      else if (prop.startsWith("--space-") && !tokens.spacing.includes(prop)) tokens.spacing.push(prop);
+      else if (prop.startsWith("--radius-") && !tokens.radii.includes(prop)) tokens.radii.push(prop);
+      else if (prop.startsWith("--shadow-") && !tokens.shadows.includes(prop)) tokens.shadows.push(prop);
+    }
+  }
+  return tokens;
+}
+function scanFiles2(dir, extensions) {
+  const results = [];
+  if (!existsSync9(dir)) return results;
+  function walk(current) {
+    const entries = readdirSync4(current);
+    for (const entry of entries) {
+      if (entry.startsWith(".") || entry === "node_modules" || entry === "dist" || entry === "build") continue;
+      const fullPath = join9(current, entry);
+      const stat = statSync2(fullPath);
+      if (stat.isDirectory()) {
+        walk(fullPath);
+      } else if (extensions.includes(extname2(entry).toLowerCase())) {
+        results.push(fullPath);
+      }
+    }
+  }
+  walk(dir);
+  return results;
+}
+var HARDCODED_COLORS = /(?:(?:color|background(?:-color)?|border(?:-color)?|fill|stroke)\s*:\s*)(#[0-9a-fA-F]{3,8}|rgb\([^)]+\)|hsl\([^)]+\))/g;
+var TAILWIND_ARBITRARY_COLORS = /(?:bg|text|border|ring|fill|stroke)-\[#[0-9a-fA-F]{3,8}\]/g;
+var HARDCODED_FONTS = /font-size:\s*(\d+(?:\.\d+)?(?:px|rem|em))/g;
+var HARDCODED_SPACING = /(?:margin|padding|gap)(?:-(?:top|right|bottom|left|x|y))?\s*:\s*(\d+(?:\.\d+)?px)/g;
+function detectViolations(content, filePath, tokens) {
+  const violations = [];
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    if (/var\(--/.test(line)) continue;
+    let match;
+    const colorRegex = new RegExp(HARDCODED_COLORS.source, "g");
+    while ((match = colorRegex.exec(line)) !== null) {
+      violations.push({
+        type: "color",
+        file: filePath,
+        line: lineNum,
+        value: match[1],
+        suggestion: tokens.colors.length > 0 ? `Use a token: var(${tokens.colors[0]}), etc.` : "Define color tokens in DESIGN.md first"
+      });
+    }
+    const twColorRegex = new RegExp(TAILWIND_ARBITRARY_COLORS.source, "g");
+    while ((match = twColorRegex.exec(line)) !== null) {
+      violations.push({
+        type: "color",
+        file: filePath,
+        line: lineNum,
+        value: match[0],
+        suggestion: "Use Tailwind theme colors instead of arbitrary values"
+      });
+    }
+    const fontRegex = new RegExp(HARDCODED_FONTS.source, "g");
+    while ((match = fontRegex.exec(line)) !== null) {
+      violations.push({
+        type: "typography",
+        file: filePath,
+        line: lineNum,
+        value: match[1],
+        suggestion: tokens.typography.length > 0 ? `Use a token: var(${tokens.typography[0]}), etc.` : "Define typography tokens in DESIGN.md first"
+      });
+    }
+    const spacingRegex = new RegExp(HARDCODED_SPACING.source, "g");
+    while ((match = spacingRegex.exec(line)) !== null) {
+      const px = parseInt(match[1]);
+      const standardSpacing = [0, 1, 2, 4, 8, 12, 16, 20, 24, 32, 40, 48, 64, 80, 96];
+      if (!standardSpacing.includes(px)) {
+        violations.push({
+          type: "spacing",
+          file: filePath,
+          line: lineNum,
+          value: match[1],
+          suggestion: `${px}px is not on the spacing scale. Nearest: ${standardSpacing.reduce((a, b) => Math.abs(b - px) < Math.abs(a - px) ? b : a)}px`
+        });
+      }
+    }
+  }
+  return violations;
+}
+function runDesignScore(projectRoot, targetDir) {
+  const scanDir = targetDir ?? join9(projectRoot, "src");
+  const designTokens = extractTokensFromDesign(projectRoot);
+  const cssTokens = extractTokensFromCSS(projectRoot);
+  const tokens = {
+    colors: [.../* @__PURE__ */ new Set([...designTokens.colors, ...cssTokens.colors])],
+    typography: [.../* @__PURE__ */ new Set([...designTokens.typography, ...cssTokens.typography])],
+    spacing: [.../* @__PURE__ */ new Set([...designTokens.spacing, ...cssTokens.spacing])],
+    radii: [.../* @__PURE__ */ new Set([...designTokens.radii, ...cssTokens.radii])],
+    shadows: [.../* @__PURE__ */ new Set([...designTokens.shadows, ...cssTokens.shadows])]
+  };
+  const files = scanFiles2(scanDir, [".css", ".scss", ".tsx", ".jsx"]);
+  const allViolations = [];
+  let tokenUsageCount = 0;
+  for (const file of files) {
+    const content = readFileSync6(file, "utf-8");
+    const relPath = file.replace(projectRoot + "/", "");
+    const tokenRefs = content.match(/var\(--/g);
+    if (tokenRefs) tokenUsageCount += tokenRefs.length;
+    const twThemeRefs = content.match(/(?:text|bg|border|ring|shadow|font|space|rounded)-(?![\[{])/g);
+    if (twThemeRefs) tokenUsageCount += twThemeRefs.length;
+    const violations = detectViolations(content, relPath, tokens);
+    allViolations.push(...violations);
+  }
+  const checks = [
+    {
+      name: "Color tokens defined",
+      passed: tokens.colors.length >= 3,
+      details: tokens.colors.length >= 3 ? `${tokens.colors.length} color tokens found` : `Only ${tokens.colors.length} color tokens \u2014 need at least 3 (primary, secondary, neutral)`
+    },
+    {
+      name: "Typography hierarchy",
+      passed: tokens.typography.length >= 2,
+      details: tokens.typography.length >= 2 ? `${tokens.typography.length} typography tokens \u2014 hierarchy established` : `Only ${tokens.typography.length} typography token(s) \u2014 need heading + body at minimum`
+    },
+    {
+      name: "Spacing system",
+      passed: tokens.spacing.length >= 3,
+      details: tokens.spacing.length >= 3 ? `${tokens.spacing.length}-step spacing scale` : `Only ${tokens.spacing.length} spacing tokens \u2014 need a proper scale`
+    },
+    {
+      name: "Token adoption",
+      passed: tokenUsageCount > allViolations.length,
+      details: tokenUsageCount > allViolations.length ? `${tokenUsageCount} token refs vs ${allViolations.length} hardcoded \u2014 tokens winning` : `${tokenUsageCount} token refs vs ${allViolations.length} hardcoded \u2014 hardcoded values dominate`
+    },
+    {
+      name: "No excessive hardcoded colors",
+      passed: allViolations.filter((v) => v.type === "color").length <= 5,
+      details: `${allViolations.filter((v) => v.type === "color").length} hardcoded color(s) found`
+    }
+  ];
+  const passedChecks = checks.filter((c) => c.passed).length;
+  const violationPenalty = Math.min(allViolations.length, 20);
+  let score;
+  if (files.length === 0) {
+    score = "-";
+  } else if (passedChecks >= 5 && violationPenalty <= 2) {
+    score = "A";
+  } else if (passedChecks >= 4 && violationPenalty <= 5) {
+    score = "B";
+  } else if (passedChecks >= 3 && violationPenalty <= 10) {
+    score = "C";
+  } else if (passedChecks >= 2) {
+    score = "D";
+  } else {
+    score = "F";
+  }
+  return {
+    score,
+    tokensFound: tokens,
+    tokenUsageCount,
+    hardcodedCount: allViolations.length,
+    violations: allViolations.slice(0, 30),
+    // Limit output
+    checks
+  };
+}
+
+// src/display.ts
+import chalk from "chalk";
+var ICONS = {
+  pass: chalk.green("\u2713"),
+  fail: chalk.red("\u2717"),
+  pending: chalk.yellow("\u25CB"),
+  locked: chalk.dim("\u25CC"),
+  active: chalk.cyan("\u25BA"),
+  completed: chalk.green("\u25CF"),
+  skipped: chalk.dim("\u25CB")
+};
+function displayBanner() {
+  console.log(chalk.bold(`
+  \u2588\u2588\u2588\u2588\u2588\u2588   \u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588
+  \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588         \u2588\u2588    \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588
+  \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588\u2588    \u2588\u2588    \u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588   \u2588\u2588
+  \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588      \u2588\u2588   \u2588\u2588    \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588
+  \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588   \u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588\u2588   \u2588\u2588    \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588
+  `));
+  console.log(chalk.dim("  Born from many. Better than all.\n"));
+}
+function displayStatus(state) {
+  console.log(chalk.bold(`
+  Project: ${state.project}`));
+  console.log(chalk.dim(`  Created: ${new Date(state.createdAt).toLocaleDateString()}`));
+  console.log(chalk.bold(`  Current: Round ${state.currentRound}
+`));
+  console.log(chalk.bold("  Pipeline:\n"));
+  for (const round of ROUNDS) {
+    const rs = state.rounds[String(round.id)];
+    if (!rs) continue;
+    let icon;
+    let style;
+    switch (rs.status) {
+      case "completed":
+        icon = ICONS.completed;
+        style = chalk.green;
+        break;
+      case "active":
+        icon = ICONS.active;
+        style = chalk.cyan.bold;
+        break;
+      case "locked":
+        icon = ICONS.locked;
+        style = chalk.dim;
+        break;
+      case "skipped":
+        icon = ICONS.skipped;
+        style = chalk.dim;
+        break;
+    }
+    const gateIcon = rs.gate === "passed" ? chalk.green(" [GATE \u2713]") : rs.gate === "failed" ? chalk.red(" [GATE \u2717]") : "";
+    const frameworks = chalk.dim(` [${round.frameworks.join(" + ")}]`);
+    console.log(`  ${icon} ${style(`Round ${round.id} \u2014 ${round.name}`)}${frameworks}${gateIcon}`);
+  }
+  console.log();
+}
+function displayGateReport(report) {
+  const round = ROUNDS.find((r) => r.id === report.roundId);
+  if (!round) return;
+  const status = report.allPassed ? chalk.green.bold("PASSED") : chalk.red.bold("FAILED");
+  console.log(chalk.bold(`
+  Gate Check \u2014 Round ${round.id}: ${round.name} \u2014 ${status}
+`));
+  for (const result of report.results) {
+    const icon = result.passed ? ICONS.pass : ICONS.fail;
+    console.log(`  ${icon} ${result.message}`);
+  }
+  if (report.details.size > 0) {
+    for (const [checkId, validation] of report.details) {
+      if (!validation.fileExists || validation.allPassed) continue;
+      console.log(chalk.dim(`
+  Details for ${validation.path}:`));
+      for (const s of validation.sections) {
+        if (!s.exists) {
+          console.log(chalk.dim(`    ${ICONS.fail} Section "${s.heading}" not found`));
+        } else if (!s.meetsMinLength) {
+          console.log(chalk.dim(`    ${ICONS.fail} "${s.heading}" \u2014 ${s.contentLength} chars (template content doesn't count)`));
+        } else if (s.patternMatched === false) {
+          console.log(chalk.dim(`    ${ICONS.fail} "${s.heading}" \u2014 ${s.patternDescription}`));
+        } else {
+          console.log(chalk.dim(`    ${ICONS.pass} "${s.heading}" \u2014 ${s.contentLength} chars`));
+        }
+      }
+    }
+  }
+  if (report.allPassed) {
+    console.log(chalk.green(`
+  Gate passed. Run ${chalk.bold("bastard next")} to advance.
+`));
+  } else {
+    const failed = report.results.filter((r) => !r.passed);
+    console.log(chalk.red(`
+  ${failed.length} check(s) failed. Fix them and run ${chalk.bold("bastard gate")} again.
+`));
+  }
+}
+function displayHooksInstalled(result) {
+  if (result.created) {
+    console.log(chalk.green(`
+  Hooks installed at ${result.path}
+`));
+  } else if (result.merged) {
+    console.log(chalk.green(`
+  Hooks merged into ${result.path}
+`));
+  }
+  console.log(chalk.bold("  Active guards:\n"));
+  console.log(`  ${ICONS.active} No source code before Round 5`);
+  console.log(`  ${ICONS.active} No CSS/styling before Round 2 gate passes`);
+  console.log(`  ${ICONS.active} No task files before Round 4`);
+  console.log(`  ${ICONS.active} Security-sensitive files flagged after Round 5`);
+  console.log(`  ${ICONS.active} git add . / git add -A blocked`);
+  console.log(`  ${ICONS.active} Direct commits to main/master blocked`);
+  console.log();
+}
+function displayValidation(validation) {
+  const status = validation.allPassed ? chalk.green.bold("VALID") : chalk.red.bold("INVALID");
+  console.log(chalk.bold(`
+  ${validation.description} \u2014 ${validation.path} \u2014 ${status}
+`));
+  if (!validation.fileExists) {
+    console.log(`  ${ICONS.fail} File not found
+`);
+    return;
+  }
+  for (const s of validation.sections) {
+    const parts = [];
+    if (!s.exists) {
+      console.log(`  ${ICONS.fail} ${s.heading} \u2014 section not found`);
+      continue;
+    }
+    parts.push(`${s.contentLength} chars`);
+    if (!s.meetsMinLength) parts.push(chalk.red("below minimum"));
+    if (s.patternMatched === true) parts.push(chalk.green("pattern ok"));
+    if (s.patternMatched === false) parts.push(chalk.red(`missing: ${s.patternDescription}`));
+    const icon = s.meetsMinLength && s.patternMatched !== false ? ICONS.pass : ICONS.fail;
+    console.log(`  ${icon} ${s.heading} \u2014 ${parts.join(", ")}`);
+  }
+  console.log();
+}
+function displayHistory(state, limit = 10) {
+  console.log(chalk.bold("\n  History:\n"));
+  const entries = state.history.slice(-limit).reverse();
+  for (const entry of entries) {
+    const date = new Date(entry.timestamp).toLocaleString();
+    const action = chalk.cyan(entry.action.padEnd(16));
+    const round = chalk.dim(`R${entry.round}`);
+    const details = entry.details ? chalk.dim(` \u2014 ${entry.details}`) : "";
+    console.log(`  ${chalk.dim(date)}  ${action} ${round}${details}`);
+  }
+  console.log();
+}
+function displayInit(projectName, created) {
+  displayBanner();
+  console.log(chalk.green.bold(`  Project "${projectName}" initialized.
+`));
+  if (created.length > 0) {
+    console.log(chalk.bold("  Templates created:\n"));
+    for (const path of created) {
+      console.log(`  ${chalk.green("+")} ${path}`);
+    }
+  }
+  console.log(chalk.bold("\n  Next steps:\n"));
+  console.log(`  1. Run ${chalk.cyan("bastard hooks install")} to enforce pipeline rules`);
+  console.log(`  2. Run ${chalk.cyan("bastard run")} to see the Round 1 workflow`);
+  console.log(`  3. Fill the product docs (PRD, Personas, Acceptance Criteria)`);
+  console.log(`  4. Run ${chalk.cyan("bastard gate")} \u2192 ${chalk.cyan("bastard approve 1")} \u2192 ${chalk.cyan("bastard next")}
+`);
+}
+function displayParents(statuses) {
+  console.log(chalk.bold("\n  Parent Frameworks:\n"));
+  for (const s of statuses) {
+    const icon = s.installed ? ICONS.pass : ICONS.fail;
+    const name = s.installed ? chalk.green(s.framework.name.padEnd(18)) : chalk.red(s.framework.name.padEnd(18));
+    const role = chalk.dim(s.framework.role);
+    const rounds = chalk.dim(` (R${s.framework.rounds.join(",")})`);
+    const via = s.detectedVia ? chalk.dim(` \u2014 via ${s.detectedVia}`) : "";
+    console.log(`  ${icon} ${name} ${role}${rounds}${via}`);
+  }
+  const missing = statuses.filter((s) => !s.installed);
+  if (missing.length > 0) {
+    console.log(chalk.bold("\n  Install missing:\n"));
+    console.log(`  ${chalk.cyan("bastard parents install")}        Install all missing`);
+    console.log(`  ${chalk.cyan("bastard parents install --force")} Update all to latest
+`);
+  } else {
+    console.log(chalk.green("\n  All 7 parents installed.\n"));
+    console.log(chalk.dim(`  Run ${chalk.cyan("bastard parents install --force")} to update all to latest.
+`));
+  }
+}
+function displayInstallProgress(result, index, total) {
+  const progress = chalk.dim(`[${index}/${total}]`);
+  if (result.alreadyInstalled) {
+    console.log(`  ${progress} ${ICONS.pass} ${result.name} \u2014 already installed`);
+  } else if (result.success && result.updated) {
+    console.log(`  ${progress} ${chalk.cyan("\u2191")} ${result.name} \u2014 updated ${chalk.dim(`(${result.duration}ms)`)}`);
+  } else if (result.success) {
+    console.log(`  ${progress} ${ICONS.pass} ${result.name} \u2014 installed ${chalk.dim(`(${result.duration}ms)`)}`);
+  } else {
+    console.log(`  ${progress} ${ICONS.fail} ${result.name} \u2014 ${chalk.red("failed")}`);
+    if (result.error) {
+      console.log(chalk.dim(`         ${result.error.split("\n")[0]}`));
+    }
+  }
+}
+function displayInstallSummary(results) {
+  const installed = results.filter((r) => r.success && !r.alreadyInstalled && !r.updated);
+  const updated = results.filter((r) => r.success && r.updated);
+  const skipped = results.filter((r) => r.alreadyInstalled);
+  const failed = results.filter((r) => !r.success);
+  console.log();
+  if (installed.length > 0) console.log(chalk.green(`  ${installed.length} installed`));
+  if (updated.length > 0) console.log(chalk.cyan(`  ${updated.length} updated`));
+  if (skipped.length > 0) console.log(chalk.dim(`  ${skipped.length} already up to date`));
+  if (failed.length > 0) {
+    console.log(chalk.red(`  ${failed.length} failed:`));
+    for (const f of failed) {
+      console.log(chalk.red(`    - ${f.name}: ${f.error?.split("\n")[0] ?? "unknown error"}`));
+    }
+  }
+  console.log();
+}
+function displayWorkflow(workflow, installedFrameworks) {
+  console.log(chalk.bold(`
+  Round ${workflow.roundId} \u2014 ${workflow.name}
+`));
+  console.log(chalk.dim(`  ${workflow.contextAdvice}
+`));
+  for (let i = 0; i < workflow.steps.length; i++) {
+    const step = workflow.steps[i];
+    const num = i + 1;
+    const installed = installedFrameworks.has(step.framework);
+    const fwBadge = installed ? chalk.green(`[${step.framework}]`) : chalk.yellow(`[${step.framework}?]`);
+    console.log(chalk.bold(`  Step ${num}: ${step.description}  ${fwBadge}`));
+    if (installed) {
+      console.log(`    ${chalk.cyan("\u2192")} ${chalk.cyan(step.action)}`);
+    } else if (step.fallbackAction) {
+      console.log(`    ${chalk.yellow("\u2192")} ${step.fallbackAction}`);
+    }
+    if (step.output) {
+      console.log(chalk.dim(`    Output: ${step.output}`));
+    }
+    if (step.isManual) {
+      console.log(chalk.dim("    (manual step \u2014 requires human input)"));
+    }
+    console.log();
+  }
+  console.log(chalk.bold("  After completion:\n"));
+  for (const cmd of workflow.completionSteps) {
+    console.log(`    ${chalk.cyan("$")} ${chalk.cyan(cmd)}`);
+  }
+  console.log();
+}
+function scoreColor(score) {
+  switch (score) {
+    case "A":
+      return chalk.green.bold;
+    case "B":
+      return chalk.green;
+    case "C":
+      return chalk.yellow;
+    case "D":
+      return chalk.red;
+    case "F":
+      return chalk.red.bold;
+    default:
+      return chalk.dim;
+  }
+}
+function displaySlopReport(report) {
+  const color = scoreColor(report.score);
+  console.log(chalk.bold("\n  AI Slop Score: ") + color(report.score) + "\n");
+  console.log(chalk.dim(`  Scanned ${report.scannedFiles} file(s)
+`));
+  if (report.matches.length === 0) {
+    console.log(chalk.green("  No slop patterns detected. Clean design.\n"));
+    return;
+  }
+  console.log(chalk.bold("  Patterns detected:\n"));
+  for (const [name, count] of Object.entries(report.summary)) {
+    const match = report.matches.find((m) => m.patternName === name);
+    const severity = match?.severity === "major" ? chalk.red("[MAJOR]") : chalk.yellow("[minor]");
+    console.log(`  ${severity} ${name}: ${count} occurrence(s)`);
+  }
+  const shown = report.matches.slice(0, 15);
+  if (shown.length > 0) {
+    console.log(chalk.bold("\n  Details:\n"));
+    for (const m of shown) {
+      const sev = m.severity === "major" ? chalk.red("!") : chalk.yellow("~");
+      console.log(`  ${sev} ${chalk.dim(m.file)}:${m.line}`);
+      console.log(`    ${chalk.dim(m.excerpt)}`);
+    }
+    if (report.matches.length > 15) {
+      console.log(chalk.dim(`
+  ... and ${report.matches.length - 15} more.`));
+    }
+  }
+  console.log();
+  if (report.score === "A") {
+    console.log(chalk.green("  Distinctive design \u2014 no AI slop detected.\n"));
+  } else if (report.score === "B") {
+    console.log(chalk.green("  Minor generic elements. Acceptable for merge.\n"));
+  } else {
+    console.log(chalk.red(`  Score ${report.score} \u2014 below merge threshold (need A). Fix the patterns above.
+`));
+  }
+}
+function displayDesignScore(report) {
+  const color = scoreColor(report.score);
+  console.log(chalk.bold("\n  Design Score: ") + color(report.score) + "\n");
+  const t = report.tokensFound;
+  const total = t.colors.length + t.typography.length + t.spacing.length + t.radii.length + t.shadows.length;
+  console.log(chalk.bold("  Token inventory:"));
+  console.log(`    Colors:     ${t.colors.length}`);
+  console.log(`    Typography: ${t.typography.length}`);
+  console.log(`    Spacing:    ${t.spacing.length}`);
+  console.log(`    Radii:      ${t.radii.length}`);
+  console.log(`    Shadows:    ${t.shadows.length}`);
+  console.log(chalk.dim(`    Total: ${total} tokens
+`));
+  console.log(chalk.bold("  Design checks:\n"));
+  for (const check of report.checks) {
+    const icon = check.passed ? ICONS.pass : ICONS.fail;
+    console.log(`  ${icon} ${check.name} \u2014 ${chalk.dim(check.details)}`);
+  }
+  console.log(chalk.bold(`
+  Token usage: ${report.tokenUsageCount} refs | Hardcoded: ${report.hardcodedCount} violations
+`));
+  if (report.violations.length > 0) {
+    console.log(chalk.bold("  Violations:\n"));
+    const shown = report.violations.slice(0, 15);
+    for (const v of shown) {
+      console.log(`  ${ICONS.fail} ${chalk.dim(v.file)}:${v.line} \u2014 ${chalk.red(v.value)}`);
+      console.log(`    ${chalk.dim(v.suggestion)}`);
+    }
+    if (report.violations.length > 15) {
+      console.log(chalk.dim(`
+  ... and ${report.violations.length - 15} more. (showing first 15)`));
+    }
+  }
+  console.log();
+  if (report.score === "-") {
+    console.log(chalk.dim("  No UI files found to score.\n"));
+  } else if (["A", "B"].includes(report.score)) {
+    console.log(chalk.green(`  Design Score ${report.score} \u2014 meets merge threshold (>= B).
+`));
+  } else {
+    console.log(chalk.red(`  Design Score ${report.score} \u2014 below merge threshold (need >= B).
+`));
+  }
+}
+function displayAudit(slop, design) {
+  displayBanner();
+  console.log(chalk.bold("  Visual Audit Report\n"));
+  const slopColor = scoreColor(slop.score);
+  const designColor = scoreColor(design.score);
+  console.log(`  AI Slop Score:  ${slopColor(slop.score)}`);
+  console.log(`  Design Score:   ${designColor(design.score)}`);
+  const canMerge = slop.score === "A" && (design.score === "A" || design.score === "B" || design.score === "-");
+  console.log(`
+  Merge verdict:  ${canMerge ? chalk.green.bold("PASS") : chalk.red.bold("FAIL")}`);
+  if (!canMerge) {
+    if (slop.score !== "A") {
+      console.log(chalk.red(`    AI Slop must be A (currently ${slop.score})`));
+    }
+    if (design.score !== "-" && !["A", "B"].includes(design.score)) {
+      console.log(chalk.red(`    Design must be >= B (currently ${design.score})`));
+    }
+  }
+  console.log();
+}
+
+// src/cli.ts
+var program = new Command();
+program.name("bastard").description("Build Any SaaS Through Agent Roles & Discipline").version("1.0.0");
+program.command("init [name]").description("Initialize a new BASTARD project").option("--install-parents", "Also install all parent frameworks").option("--with-hooks", "Also install Claude Code guard hooks").action(async (name, opts) => {
+  const projectRoot = process.cwd();
+  if (stateExists(projectRoot)) {
+    console.log(chalk2.yellow("\n  BASTARD project already initialized here.\n"));
+    console.log(`  Run ${chalk2.cyan("bastard status")} to see current state.
+`);
+    return;
+  }
+  const projectName = name ?? basename(projectRoot);
+  const dirs = [
+    "docs/product",
+    "docs/design/mockups",
+    "docs/architecture/ADR",
+    "docs/security",
+    "docs/planning",
+    ".planning",
+    "tasks",
+    "src",
+    "tests",
+    ".bastard"
+  ];
+  for (const dir of dirs) {
+    const fullPath = resolve3(projectRoot, dir);
+    if (!existsSync10(fullPath)) {
+      mkdirSync5(fullPath, { recursive: true });
+    }
+  }
+  const state = createInitialState(projectName);
+  saveState(projectRoot, state);
+  const created = scaffoldTemplates(projectRoot, projectName);
+  displayInit(projectName, created);
+  if (opts.installParents) {
+    console.log(chalk2.bold("  Installing parent frameworks...\n"));
+    const results = await installParents(
+      projectRoot,
+      {},
+      (result, index, total) => displayInstallProgress(result, index, total)
+    );
+    displayInstallSummary(results);
+  }
+  if (opts.withHooks) {
+    const hookResult = installHooks(projectRoot);
+    displayHooksInstalled(hookResult);
+  }
+});
+program.command("status").description("Show current pipeline status").action(() => {
+  const projectRoot = process.cwd();
+  const state = loadState(projectRoot);
+  displayBanner();
+  displayStatus(state);
+});
+program.command("gate [round]").description("Run gate checks for a round (default: current)").action((roundArg) => {
+  const projectRoot = process.cwd();
+  const state = loadState(projectRoot);
+  const roundId = roundArg ? parseInt(roundArg, 10) : state.currentRound;
+  const round = getRound(roundId);
+  if (!round) {
+    console.log(chalk2.red(`
+  Round ${roundId} does not exist.
+`));
+    return;
+  }
+  const report = runGate(projectRoot, state, roundId);
+  saveState(projectRoot, state);
+  displayGateReport(report);
+});
+program.command("approve <round>").description("Human-approve a round gate").action((roundArg) => {
+  const projectRoot = process.cwd();
+  const state = loadState(projectRoot);
+  const roundId = parseInt(roundArg, 10);
+  const round = getRound(roundId);
+  if (!round) {
+    console.log(chalk2.red(`
+  Round ${roundId} does not exist.
+`));
+    return;
+  }
+  approveGate(state, roundId);
+  const report = runGate(projectRoot, state, roundId);
+  saveState(projectRoot, state);
+  console.log(chalk2.green(`
+  Round ${roundId} approved by human.
+`));
+  displayGateReport(report);
+});
+program.command("next").description("Advance to the next round (if gate passes)").action(() => {
+  const projectRoot = process.cwd();
+  const state = loadState(projectRoot);
+  const currentRound = state.currentRound;
+  const report = runGate(projectRoot, state, currentRound);
+  if (!report.allPassed) {
+    saveState(projectRoot, state);
+    displayGateReport(report);
+    console.log(chalk2.red(`  Cannot advance \u2014 Round ${currentRound} gate not passed.
+`));
+    return;
+  }
+  const advanced = advanceRound(state);
+  saveState(projectRoot, state);
+  if (state.currentRound > 8 || currentRound === 8 && advanced) {
+    displayBanner();
+    console.log(chalk2.green.bold("  All 8 rounds completed. Ship it.\n"));
+    displayStatus(state);
+    return;
+  }
+  if (advanced) {
+    const nextRound = getRound(state.currentRound);
+    console.log(chalk2.green.bold(`
+  Advanced to Round ${state.currentRound} \u2014 ${nextRound?.name}
+`));
+    console.log(chalk2.dim(`  Frameworks: [${nextRound?.frameworks.join(" + ")}]`));
+    console.log(chalk2.dim(`  ${nextRound?.description}
+`));
+    console.log(chalk2.bold("  Gate requirements:\n"));
+    for (const check of nextRound?.gateChecks ?? []) {
+      console.log(`  ${chalk2.yellow("\u25CB")} ${check.description}`);
+    }
+    console.log();
+  } else {
+    console.log(chalk2.red(`
+  Could not advance from Round ${currentRound}.
+`));
+  }
+});
+program.command("round <number>").description("Jump to a specific round (with warnings)").action((roundArg) => {
+  const projectRoot = process.cwd();
+  const state = loadState(projectRoot);
+  const targetRound = parseInt(roundArg, 10);
+  const round = getRound(targetRound);
+  if (!round) {
+    console.log(chalk2.red(`
+  Round ${targetRound} does not exist.
+`));
+    return;
+  }
+  const skipped = [];
+  for (let i = 1; i < targetRound; i++) {
+    const rs = state.rounds[String(i)];
+    if (rs && rs.gate !== "passed") {
+      skipped.push(i);
+    }
+  }
+  if (skipped.length > 0) {
+    console.log(chalk2.yellow(`
+  \u26A0 WARNING: Skipping rounds with unpassed gates: ${skipped.join(", ")}`));
+    console.log(chalk2.yellow("  This violates the BASTARD pipeline. Proceed at your own risk.\n"));
+    for (const r of skipped) {
+      state.rounds[String(r)].status = "skipped";
+    }
+  }
+  state.currentRound = targetRound;
+  state.rounds[String(targetRound)].status = "active";
+  state.rounds[String(targetRound)].startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  state.history.push({
+    action: "jump",
+    round: targetRound,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    details: skipped.length > 0 ? `Jumped to Round ${targetRound}, skipping ${skipped.join(", ")}` : `Jumped to Round ${targetRound}`
+  });
+  saveState(projectRoot, state);
+  console.log(chalk2.cyan(`
+  Now on Round ${targetRound} \u2014 ${round.name}
+`));
+});
+program.command("history").description("Show action history").option("-n, --limit <number>", "Number of entries", "20").action((opts) => {
+  const projectRoot = process.cwd();
+  const state = loadState(projectRoot);
+  displayHistory(state, parseInt(opts.limit, 10));
+});
+program.command("reset").description("Reset pipeline to Round 1 (keeps files)").action(() => {
+  const projectRoot = process.cwd();
+  const state = loadState(projectRoot);
+  for (const [id, rs] of Object.entries(state.rounds)) {
+    rs.status = id === "1" ? "active" : "locked";
+    rs.gate = "pending";
+    rs.gateResults = [];
+    rs.completedAt = null;
+    if (id === "1") {
+      rs.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    } else {
+      rs.startedAt = null;
+    }
+  }
+  state.currentRound = 1;
+  state.history.push({
+    action: "reset",
+    round: 1,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    details: "Pipeline reset to Round 1"
+  });
+  saveState(projectRoot, state);
+  console.log(chalk2.yellow("\n  Pipeline reset to Round 1. Files preserved.\n"));
+});
+program.command("validate [schema]").description("Validate a document against its schema (prd, design, architecture, ...)").action((schemaArg) => {
+  const projectRoot = process.cwd();
+  if (schemaArg) {
+    const schema = SCHEMAS[schemaArg];
+    if (!schema) {
+      console.log(chalk2.red(`
+  Unknown schema: "${schemaArg}"`));
+      console.log(`  Available: ${Object.keys(SCHEMAS).join(", ")}
+`);
+      return;
+    }
+    const result = validateDocument(projectRoot, schema);
+    displayValidation(result);
+    return;
+  }
+  console.log(chalk2.bold("\n  Document Validation Report\n"));
+  let allValid = true;
+  for (const [key, schema] of Object.entries(SCHEMAS)) {
+    if (!schema.path) continue;
+    const result = validateDocument(projectRoot, schema);
+    const icon = result.allPassed ? chalk2.green("\u2713") : result.fileExists ? chalk2.red("\u2717") : chalk2.dim("\u25CB");
+    const status = result.allPassed ? chalk2.green("valid") : result.fileExists ? chalk2.red("invalid") : chalk2.dim("missing");
+    console.log(`  ${icon} ${key.padEnd(18)} ${schema.path.padEnd(45)} ${status}`);
+    if (!result.allPassed) allValid = false;
+  }
+  console.log();
+  if (!allValid) {
+    console.log(chalk2.dim(`  Run ${chalk2.cyan("bastard validate <schema>")} for details.
+`));
+  }
+});
+program.command("guard").description("Guard for Claude Code hooks (reads tool JSON from stdin)").action(async () => {
+  const projectRoot = process.cwd();
+  await runGuardFromStdin(projectRoot);
+});
+var hooksCmd = program.command("hooks").description("Manage Claude Code hooks for pipeline enforcement");
+hooksCmd.command("install").description("Install guard hooks into .claude/settings.local.json").action(() => {
+  const projectRoot = process.cwd();
+  const result = installHooks(projectRoot);
+  displayHooksInstalled(result);
+});
+hooksCmd.command("remove").description("Remove guard hooks from .claude/settings.local.json").action(() => {
+  const projectRoot = process.cwd();
+  const removed = removeHooks(projectRoot);
+  if (removed) {
+    console.log(chalk2.yellow("\n  BASTARD hooks removed from .claude/settings.local.json\n"));
+  } else {
+    console.log(chalk2.dim("\n  No hooks file found \u2014 nothing to remove.\n"));
+  }
+});
+var parentsCmd = program.command("parents").description("Manage parent frameworks");
+parentsCmd.command("list", { isDefault: true }).description("Show installed/missing parent frameworks").action(() => {
+  const projectRoot = process.cwd();
+  const statuses = detectParents(projectRoot);
+  displayParents(statuses);
+});
+parentsCmd.command("install").description("Install/update all parent frameworks (always fetches latest)").option("--force", "Reinstall and update all parents to latest version").option("--only <ids>", "Only install these frameworks (comma-separated: bmad,gsd,gstack,...)").option("--skip <ids>", "Skip these frameworks (comma-separated)").action(async (opts) => {
+  const projectRoot = process.cwd();
+  const force = opts.force ?? false;
+  const only = opts.only ? opts.only.split(",").map((s) => s.trim()) : void 0;
+  const skip = opts.skip ? opts.skip.split(",").map((s) => s.trim()) : void 0;
+  console.log(chalk2.bold("\n  Installing parent frameworks...\n"));
+  if (force) {
+    console.log(chalk2.cyan("  --force: updating all to latest\n"));
+  }
+  const results = await installParents(
+    projectRoot,
+    { force, only, skip },
+    (result, index, total) => displayInstallProgress(result, index, total)
+  );
+  displayInstallSummary(results);
+  const statuses = detectParents(projectRoot);
+  displayParents(statuses);
+});
+program.command("run [round]").description("Show workflow for a round with framework-aware steps (default: current)").action((roundArg) => {
+  const projectRoot = process.cwd();
+  let roundId;
+  if (roundArg) {
+    roundId = parseInt(roundArg, 10);
+  } else if (stateExists(projectRoot)) {
+    const state = loadState(projectRoot);
+    roundId = state.currentRound;
+  } else {
+    roundId = 1;
+  }
+  const workflow = getWorkflow(roundId);
+  if (!workflow) {
+    console.log(chalk2.red(`
+  No workflow defined for Round ${roundId}.
+`));
+    return;
+  }
+  const statuses = detectParents(projectRoot);
+  const installed = new Set(statuses.filter((s) => s.installed).map((s) => s.framework.id));
+  const needed = workflow.steps.map((s) => s.framework);
+  const missingForRound = [...new Set(needed)].filter((fw) => !installed.has(fw));
+  if (missingForRound.length > 0) {
+    console.log(chalk2.yellow(`
+  Missing frameworks for Round ${roundId}: ${missingForRound.join(", ")}`));
+    console.log(chalk2.dim("  Fallback instructions will be shown for missing frameworks.\n"));
+  }
+  displayWorkflow(workflow, installed);
+});
+program.command("prompt [round]").description("Generate a copy-pasteable prompt for a round (default: current)").action((roundArg) => {
+  const projectRoot = process.cwd();
+  let roundId;
+  if (roundArg) {
+    roundId = parseInt(roundArg, 10);
+  } else if (stateExists(projectRoot)) {
+    const state = loadState(projectRoot);
+    roundId = state.currentRound;
+  } else {
+    roundId = 1;
+  }
+  const workflow = getWorkflow(roundId);
+  if (!workflow) {
+    console.log(chalk2.red(`
+  No workflow defined for Round ${roundId}.
+`));
+    return;
+  }
+  const statuses = detectParents(projectRoot);
+  const installed = new Set(statuses.filter((s) => s.installed).map((s) => s.framework.id));
+  const prompt = generatePrompt(workflow, installed);
+  console.log(prompt);
+});
+function resolveAuditTarget(pathArg) {
+  const cwd = process.cwd();
+  if (pathArg) return resolve3(cwd, pathArg);
+  const srcDir = resolve3(cwd, "src");
+  return existsSync10(srcDir) ? srcDir : cwd;
+}
+program.command("slop [path]").description("Scan for AI slop patterns \u2014 works on ANY project (default: src/ or cwd)").action((pathArg) => {
+  const targetDir = resolveAuditTarget(pathArg);
+  const report = runSlopScan(targetDir);
+  displaySlopReport(report);
+});
+program.command("score [path]").description("Check design token compliance \u2014 works on ANY project").action((pathArg) => {
+  const targetDir = resolveAuditTarget(pathArg);
+  const report = runDesignScore(targetDir, targetDir);
+  displayDesignScore(report);
+});
+program.command("audit [path]").description("AI Slop + Design Score audit \u2014 works on ANY project, no init needed").action((pathArg) => {
+  const targetDir = resolveAuditTarget(pathArg);
+  const slop = runSlopScan(targetDir);
+  const design = runDesignScore(targetDir, targetDir);
+  displayAudit(slop, design);
+  if (slop.matches.length > 0) {
+    displaySlopReport(slop);
+  }
+  if (design.violations.length > 0) {
+    displayDesignScore(design);
+  }
+});
+program.parse();