100xprism 2.3.1

package/modules/free-tool-strategy/evals/evals.json

@@ -0,0 +1,90 @@
+{
+  "skill_name": "free-tool-strategy",
+  "evals": [
+    {
+      "id": 1,
+      "prompt": "We want to build a free tool to drive leads for our SEO software. We're thinking about an SEO audit tool or a keyword research tool. Which would be better and how should we approach it?",
+      "expected_output": "Should check for product-marketing-context.md first. Should apply the evaluation scorecard to compare both tool ideas across dimensions (audience alignment, lead quality, build effort, SEO value, maintenance burden, competitive differentiation). Should reference the tool types from the skill (analyzers, testers). Should recommend the stronger option with rationale. Should discuss lead capture gating strategy (what's free vs what requires email). Should address MVP scope — what's the minimum valuable version. Should provide implementation recommendations.",
+      "assertions": [
+        "Checks for product-marketing-context.md",
+        "Applies evaluation scorecard to compare options",
+        "References tool types from the skill",
+        "Recommends one option with clear rationale",
+        "Discusses lead capture gating strategy",
+        "Addresses MVP scope",
+        "Provides implementation recommendations"
+      ],
+      "files": []
+    },
+    {
+      "id": 2,
+      "prompt": "I want to build a free ROI calculator for our HR software. Users input their company size and current processes, and it shows how much time and money they'd save.",
+      "expected_output": "Should identify this as a calculator tool type. Should apply the ideation framework to validate the concept. Should discuss lead capture strategy: should the basic result be free and detailed report gated? Should address the build vs buy decision. Should recommend MVP scope (what inputs, what outputs, what formula). Should discuss SEO considerations for the tool page. Should reference the evaluation scorecard to score the idea.",
+      "assertions": [
+        "Identifies as calculator tool type",
+        "Applies ideation framework to validate",
+        "Discusses lead capture gating strategy",
+        "Addresses build vs buy decision",
+        "Recommends MVP scope (inputs, outputs, formula)",
+        "Discusses SEO considerations",
+        "References evaluation scorecard"
+      ],
+      "files": []
+    },
+    {
+      "id": 3,
+      "prompt": "give me some ideas for free tools we could build. we sell email marketing software for e-commerce brands.",
+      "expected_output": "Should trigger on casual phrasing. Should apply the ideation framework to generate tool ideas relevant to email marketing + e-commerce. Should provide 5-8 ideas across different tool types (calculators, generators, analyzers, testers). Examples: email subject line tester, email deliverability checker, email ROI calculator, email template generator, spam score checker. Should briefly score each against the evaluation dimensions. Should recommend top 2-3 to pursue.",
+      "assertions": [
+        "Triggers on casual phrasing",
+        "Applies ideation framework",
+        "Generates ideas across multiple tool types",
+        "Ideas are relevant to email marketing + e-commerce",
+        "Provides 5-8 ideas",
+        "Briefly evaluates each idea",
+        "Recommends top 2-3 to pursue"
+      ],
+      "files": []
+    },
+    {
+      "id": 4,
+      "prompt": "We built a free website speed test tool 6 months ago but it's barely getting any traffic. What went wrong and how do we fix it?",
+      "expected_output": "Should diagnose why the tool isn't getting traffic. Should investigate: SEO strategy for the tool page (target keywords, on-page optimization), distribution strategy (was it launched and forgotten?), competitive landscape (are there dominant free tools already?), tool quality and UX (does it provide unique value?). Should apply the engineering as marketing principles. Should recommend a recovery plan: SEO improvements, content marketing around the tool, product improvements for differentiation.",
+      "assertions": [
+        "Diagnoses potential traffic issues",
+        "Investigates SEO strategy for the tool",
+        "Assesses competitive landscape",
+        "Questions unique value proposition",
+        "Applies engineering as marketing principles",
+        "Recommends recovery plan with specific actions"
+      ],
+      "files": []
+    },
+    {
+      "id": 5,
+      "prompt": "Should we gate our free tool behind an email capture or make it completely free? We want leads but don't want to kill usage.",
+      "expected_output": "Should apply the lead capture gating strategy framework. Should present the spectrum: fully ungated → partial gating (basic results free, detailed report gated) → fully gated. Should recommend partial gating as the typical best approach — give enough value to demonstrate the tool's worth, gate the detailed/actionable output. Should discuss tradeoffs: ungated = more SEO value and usage, gated = more leads but fewer users. Should provide specific gating recommendations based on tool type.",
+      "assertions": [
+        "Applies lead capture gating strategy",
+        "Presents gating spectrum (ungated to fully gated)",
+        "Recommends partial gating approach",
+        "Discusses tradeoffs of each approach",
+        "Provides specific gating recommendations",
+        "Addresses SEO impact of gating decisions"
+      ],
+      "files": []
+    },
+    {
+      "id": 6,
+      "prompt": "How do I optimize the landing page for our free tool to get more signups? The tool itself is great but nobody finds it.",
+      "expected_output": "Should recognize this is a landing page conversion optimization task, not a free tool strategy task. Should defer to or cross-reference the page-cro skill for optimizing the tool's landing page conversion rate. May provide free-tool-specific context (gating strategy, value demonstration) but should make clear that page-cro is the right skill for page conversion optimization.",
+      "assertions": [
+        "Recognizes this as page CRO, not free tool strategy",
+        "References or defers to page-cro skill",
+        "May provide free-tool-specific context",
+        "Does not attempt full page CRO using free tool strategy patterns"
+      ],
+      "files": []
+    }
+  ]
+}

package/modules/free-tool-strategy/references/tool-types.md

@@ -0,0 +1,217 @@
+# Free Tool Types Reference
+
+Detailed guide to each type of marketing tool you can build.
+
+## Contents
+- Calculators
+- Generators
+- Analyzers/Auditors
+- Testers/Validators
+- Libraries/Resources
+- Interactive Educational
+- Tool Concept Examples by Industry (SaaS product, agency/services, e-commerce, developer tools, finance)
+
+## Calculators
+
+**Best for**: Decisions involving numbers, comparisons, estimates
+
+**Examples**:
+- ROI calculator
+- Savings calculator
+- Cost comparison tool
+- Salary calculator
+- Tax estimator
+- Pricing estimator
+- Compound interest calculator
+- Break-even calculator
+
+**Why they work**:
+- Personalized output
+- High perceived value
+- Share-worthy results
+- Clear problem → solution
+
+**Implementation tips**:
+- Keep inputs simple
+- Show calculations transparently
+- Make results shareable
+- Add "powered by" branding
+
+---
+
+## Generators
+
+**Best for**: Creating something useful quickly
+
+**Examples**:
+- Policy generator (privacy, terms)
+- Template generator
+- Name/tagline generator
+- Email subject line generator
+- Resume builder
+- Color palette generator
+- Logo maker
+- Contract generator
+
+**Why they work**:
+- Tangible output
+- Saves time
+- Easily shared
+- Repeat usage
+
+**Implementation tips**:
+- Output should be immediately usable
+- Allow customization
+- Offer download/export options
+- Include email gating for premium outputs
+
+---
+
+## Analyzers/Auditors
+
+**Best for**: Evaluating existing work or assets
+
+**Examples**:
+- Website grader
+- SEO analyzer
+- Email subject tester
+- Headline analyzer
+- Security checker
+- Performance auditor
+- Accessibility checker
+- Code quality analyzer
+
+**Why they work**:
+- Curiosity-driven
+- Personalized insights
+- Creates awareness of problems
+- Natural lead to solution
+
+**Implementation tips**:
+- Score or grade for gamification
+- Benchmark against averages
+- Provide actionable recommendations
+- Follow up with improvement offers
+
+---
+
+## Testers/Validators
+
+**Best for**: Checking if something works
+
+**Examples**:
+- Meta tag preview
+- Email rendering test
+- Mobile-friendly test
+- Speed test
+- DNS checker
+- SSL certificate checker
+- Redirect checker
+- Broken link finder
+
+**Why they work**:
+- Immediate utility
+- Bookmark-worthy
+- Repeat usage
+- Professional necessity
+
+**Implementation tips**:
+- Fast results are essential
+- Show pass/fail clearly
+- Provide fix instructions
+- Integrate with your product where relevant
+
+---
+
+## Libraries/Resources
+
+**Best for**: Reference material
+
+**Examples**:
+- Icon library
+- Template library
+- Code snippet library
+- Example gallery
+- Industry directory
+- Resource list
+- Swipe file collection
+- Font pairing tool
+
+**Why they work**:
+- High SEO value
+- Ongoing traffic
+- Establishes authority
+- Linkable asset
+
+**Implementation tips**:
+- Make searchable/filterable
+- Allow easy copying/downloading
+- Update regularly
+- Accept community submissions
+
+---
+
+## Interactive Educational
+
+**Best for**: Learning/understanding
+
+**Examples**:
+- Interactive tutorials
+- Code playgrounds
+- Visual explainers
+- Quizzes/assessments
+- Simulators
+- Comparison tools
+- Decision trees
+- Configurators
+
+**Why they work**:
+- Engages deeply
+- Demonstrates expertise
+- Shareable
+- Memory-creating
+
+**Implementation tips**:
+- Make it hands-on
+- Show immediate feedback
+- Lead to deeper resources
+- Capture engaged users
+
+---
+
+## Tool Concept Examples by Industry
+
+### SaaS Product
+- Product ROI calculator
+- Competitor comparison tool
+- Readiness assessment quiz
+- Template library for use case
+- Feature configurator
+
+### Agency/Services
+- Industry benchmark tool
+- Project scoping calculator
+- Portfolio review tool
+- Cost estimator
+- Proposal generator
+
+### E-commerce
+- Product finder quiz
+- Comparison tool
+- Size/fit calculator
+- Savings calculator
+- Gift finder
+
+### Developer Tools
+- Code snippet library
+- Testing/preview tool
+- Documentation generator
+- Interactive tutorials
+- API playground
+
+### Finance
+- Financial calculators
+- Investment comparison
+- Budget planner
+- Tax estimator
+- Loan calculator

package/modules/gate/SKILL.md

@@ -0,0 +1,232 @@
+---
+name: gate
+description: **MANDATORY before every commit and push.** All gates must pass — Gates 1–3 always run; Gates 4 (Docker) and 5 (Cloud) run only when applicable. Do NOT proceed if any gate fails — fix the issue first.
+category: quality
+tier: core
+slash_command: /gate
+---
+
+# Gate — Pre-Commit Quality Gate
+
+**MANDATORY before every commit and push.** All gates must pass — Gates 1–3 always run; Gates 4 (Docker) and 5 (Cloud) run only when applicable. Do NOT proceed if any gate fails — fix the issue first.
+
+## Do NOT ask for permission. Do NOT skip gates. Do NOT continue past a failing gate.
+
+---
+
+## How to run the gates (fan out the independent ones)
+
+Gate 1 (the coverage loop) is the long pole — run it first and let it finish. Gates 2–5
+(**security, build, docker, cloud-security**) are mutually independent: they read the
+tree but never depend on each other's results, so **run them in parallel**, not as serial
+ASCII boxes.
+
+Use the fan-out ladder from the `subagents` skill: prefer the `Workflow` tool (one stage
+per gate, `schema`-validated return), else dispatch parallel `Agent`/`Task` subagents,
+else fall back to running them serially. Each gate subagent returns a structured verdict:
+
+```json
+{ "gate": "security", "status": "passed|failed|skipped", "severity": "critical|high|none", "findings": ["..."] }
+```
+
+The parent **reduces** the verdicts into the summary box below: any `failed` with
+critical/high severity ⇒ overall FAILED. Cache each verdict keyed on the **tree hash**
+(`git write-tree` + clean-tree check) so a re-run on an unchanged tree reuses the verdict
+instead of recomputing — the same key the `gate-pass.py` token uses (see *Record the
+pass* below). Never reuse a verdict across a changed tree.
+
+---
+
+## Gate 1 — Test Coverage (≥ 95%)
+
+Run the **test** workflow. Run ALL test layers (unit, integration, E2E if configured).
+
+Requirements:
+- Lines ≥ 95% | Functions ≥ 95% | Statements ≥ 95% | Branches ≥ 90%
+- Zero failing tests
+
+**If coverage is below threshold or tests fail → STOP. Fix tests. Re-run gate.**
+
+```
+Gate 1: Tests ✅ PASSED | ❌ FAILED — do not proceed
+```
+
+---
+
+## Gate 2 — Security (No Critical, No High)
+
+Run the **security** workflow. Scan all package managers found in this project.
+
+Requirements:
+- **Zero critical vulnerabilities**
+- **Zero high vulnerabilities**
+- No real secrets in tracked files
+
+Known exceptions accepted **only if explicitly documented** in the project's `/security` override (e.g. install-time-only transitive deps). When in doubt, treat as blocking.
+
+**If critical or high vulnerabilities exist → STOP. Fix vulnerabilities. Re-run gate.**
+
+```
+Gate 2: Security ✅ PASSED | ❌ FAILED — do not proceed
+```
+
+---
+
+## Gate 3 — Local Build
+
+Detect and run all applicable builds:
+
+```bash
+PROJECT_ROOT=$(git rev-parse --show-toplevel)
+cd "$PROJECT_ROOT"
+```
+
+**npm frontend** (if `package.json` + `vite`/`webpack`/`next` detected):
+```bash
+npm run build
+```
+
+**npm backend** (if `api/package.json` detected):
+```bash
+cd api && npm run build
+```
+
+**Python** (if `pyproject.toml` detected):
+```bash
+./venv/bin/python -m build 2>/dev/null || ./venv/bin/python -c "import py_compile, glob; [py_compile.compile(f, doraise=True) for f in glob.glob('**/*.py', recursive=True) if 'venv' not in f]"
+```
+
+Requirements:
+- Zero compiler errors
+- Zero TypeScript type errors (for TS projects)
+
+**If any build fails → STOP. Fix compiler errors. Re-run gate.**
+
+```
+Gate 3: Build ✅ PASSED | ❌ FAILED — do not proceed
+```
+
+---
+
+## Gate 4 — Docker Build (if Dockerfile present)
+
+```bash
+if [ -f "$PROJECT_ROOT/Dockerfile" ]; then
+  docker build -t $(basename "$PROJECT_ROOT"):gate-check . --quiet
+  echo "Docker build: ✅"
+else
+  echo "Docker build: skipped (no Dockerfile)"
+fi
+```
+
+If the project has a `docker-compose.yml`, also verify it starts cleanly:
+```bash
+if [ -f "$PROJECT_ROOT/deploy/docker-compose.yml" ] || [ -f "$PROJECT_ROOT/docker-compose.yml" ]; then
+  COMPOSE_FILE=${PROJECT_ROOT}/deploy/docker-compose.yml
+  [ -f "$COMPOSE_FILE" ] || COMPOSE_FILE=${PROJECT_ROOT}/docker-compose.yml
+  docker compose -f "$COMPOSE_FILE" config --quiet && echo "Compose config: ✅"
+fi
+```
+
+**If Docker build fails → STOP. Fix the Dockerfile or dependency issue. Re-run gate.**
+
+```
+Gate 4: Docker ✅ PASSED | skipped (no Dockerfile) | ❌ FAILED — do not proceed
+```
+
+---
+
+## Gate 5 — Cloud Security & Data Privacy (if cloud project)
+
+Detect whether this project deploys to a cloud provider:
+
+```bash
+PROJECT_ROOT=$(git rev-parse --show-toplevel)
+IS_CLOUD_PROJECT=false
+
+# Detect project instruction file
+INSTRUCTION_FILE=$(for f in CLAUDE.md AGENTS.md .cursorrules .windsurfrules .github/copilot-instructions.md GEMINI.md; do [ -f "$PROJECT_ROOT/$f" ] && echo "$PROJECT_ROOT/$f" && break; done)
+
+# GCP: check for gcloud config, Terraform, or project instruction file references
+if [ -n "$INSTRUCTION_FILE" ] && grep -qE "gcloud|GCP_PROJECT|GOOGLE_CLOUD_PROJECT|Cloud Run|Cloud SQL|Firebase" \
+  "$INSTRUCTION_FILE" "$PROJECT_ROOT/.env.example" 2>/dev/null; then
+  IS_CLOUD_PROJECT=true
+fi
+
+# AWS: check for aws-cli config or CDK/Terraform
+if ls "$PROJECT_ROOT/terraform/" "$PROJECT_ROOT/infra/" "$PROJECT_ROOT/cdk.json" 2>/dev/null | grep -qE "aws|cdk"; then
+  IS_CLOUD_PROJECT=true
+fi
+
+echo "Cloud project: $IS_CLOUD_PROJECT"
+```
+
+**If `IS_CLOUD_PROJECT=true`:** Run the **cloud-security** workflow. Run the full cloud security and data privacy scan.
+
+Requirements:
+- **Zero CRITICAL findings** (public data exposure, open credentials, public storage, SQL injection)
+- **Zero HIGH findings** (missing SSL, overprivileged IAM, PII in logs, missing auth headers, eval() usage)
+- MEDIUM/LOW findings: reported, non-blocking, must be tracked
+
+**If any CRITICAL or HIGH finding → STOP. Fix before committing. Cloud misconfigurations can expose user data.**
+
+**If `IS_CLOUD_PROJECT=false`:** Gate 5 is skipped.
+
+```
+Gate 5: Cloud Security ✅ PASSED | ❌ FAILED — do not proceed | skipped (local only)
+```
+
+---
+
+## Gate summary output
+
+This box is the **reduce step**: collect the structured verdict from each gate (Gate 1
+plus the parallel Gates 2–5) and aggregate. STATUS is PASSED only when every applicable
+gate reports `passed` with no critical/high severity.
+
+```
+╔══════════════════════════════════════════════════════╗
+║               QUALITY GATE RESULTS                   ║
+╠══════════════════════════════════════════════════════╣
+║ Gate 1 Tests:          ✅ PASSED  (FE 97% | BE 96%) ║
+║ Gate 2 Security:       ✅ PASSED  (0 critical, 0 high) ║
+║ Gate 3 Build:          ✅ PASSED  (FE ✅ | BE ✅)   ║
+║ Gate 4 Docker:         ✅ PASSED  | skipped          ║
+║ Gate 5 Cloud/Privacy:  ✅ PASSED  | skipped          ║
+╠══════════════════════════════════════════════════════╣
+║ STATUS: ✅ ALL GATES PASSED — safe to commit         ║
+╚══════════════════════════════════════════════════════╝
+```
+
+If ANY gate fails:
+```
+╔══════════════════════════════════════════════════════╗
+║               QUALITY GATE RESULTS                   ║
+╠══════════════════════════════════════════════════════╣
+║ Gate 1 Tests:          ❌ FAILED  (BE 88%)           ║
+║ Gate 2 Security:       ✅ PASSED                     ║
+║ Gate 3 Build:          ✅ PASSED                     ║
+║ Gate 4 Docker:         skipped                       ║
+║ Gate 5 Cloud/Privacy:  ❌ FAILED  (1 CRITICAL)       ║
+╠══════════════════════════════════════════════════════╣
+║ STATUS: ❌ GATE FAILED — fix issues before commit    ║
+╚══════════════════════════════════════════════════════╝
+```
+
+**Do NOT commit or push until the gate summary shows ALL GATES PASSED.**
+
+---
+
+## Record the pass (enables the gate-on-commit hook)
+
+**Only when the summary shows ALL GATES PASSED**, record the pass so the optional
+`gate-on-commit` hook will allow the next commit/push:
+
+```bash
+python3 ~/100xprism/hooks/gate-pass.py 2>/dev/null || true
+```
+
+This writes a token for the **current tree state** (HEAD + tracked diff + untracked
+files) to `~/.100xprism/gate-cache`. The token is invalidated the moment anything in the
+tree changes, so a later edit always re-arms the gate. If a gate **failed**, do NOT run
+this — leave the cache stale so the commit stays blocked.

package/modules/grill-me/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: grill-me
+description: Adversarial code review before a PR — Claude asks hard questions until you pass the test. Also supports elegant rewrites ("scrap this and implement the elegant solution") and spec-driven development. Use before opening any pull request.
+category: engineering
+tier: core
+slash_command: /grill
+allowed-tools: Bash(git:*) Read Grep Glob
+---
+
+# Grill — Adversarial Code Review
+
+Enter adversarial review mode. Challenge the current changes before a PR is created. Do not approve until satisfied.
+
+## How to use
+- `/grill` — adversarial review of current diff before `/pr`
+- `/grill rewrite` — scrap and implement the elegant solution
+- `/grill spec` — write detailed specs before handing off work
+
+---
+
+## Mode A — Code Review (default)
+
+```bash
+PROJECT_ROOT=$(git rev-parse --show-toplevel)
+cd "$PROJECT_ROOT"
+git diff main
+git diff --staged
+```
+
+Read the diff. Identify risks:
+
+- [ ] Does this handle the unhappy path?
+- [ ] Are there race conditions or async issues?
+- [ ] Is this the right abstraction (over- or under-engineered)?
+- [ ] Will this break anything that depends on it?
+- [ ] Are tests missing for the new behaviour?
+- [ ] Is the naming clear to someone reading this cold?
+- [ ] Could this be 50% simpler?
+
+Ask the user **3–5 hard, specific questions** about the changes. Do not accept vague answers — probe further. Only approve (and proceed with `/pr`) once satisfied.
+
+---
+
+## Mode B — Elegant Rewrite
+
+After a messy fix, start fresh:
+- Identify the root insight that makes the solution simple
+- Rewrite with that insight as the foundation — no legacy cruft
+- The elegant solution is usually 30–50% less code
+
+---
+
+## Mode C — Spec-Driven Development
+
+Ask clarifying questions until requirements are unambiguous. Produce a written spec (inputs, outputs, edge cases, acceptance criteria). Only begin implementation once spec is approved.
+
+---
+
+**GATE: User has answered all questions satisfactorily. Only then proceed to `/pr`.**

package/modules/interaction-engineer/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: interaction-engineer
+description: Act as a Senior Frontend Systems Engineer to architect interactive modules — multi-step forms, pricing calculators, faceted search, dashboards, and auth flows. Defines state machines, data flow, error handling, and React component structure. Use when designing complex UI logic for Figma Make prototypes or React implementation.
+category: design
+tier: on-demand
+allowed-tools: Read Write
+---
+
+You are a Senior Frontend Systems Engineer. Architect the functional logic for advanced interactive modules.
+
+## Required Modules (specify which to build)
+
+Choose from these or describe your own:
+
+1. **Multi-step form** — with validation and progress tracking
+2. **Real-time pricing calculator** — with dynamic computation
+3. **Faceted search** — with filtering, sorting, and pagination
+4. **User dashboard** — with analytics visualization and CRUD capability
+5. **Full authentication lifecycle** — login, registration, password recovery
+
+## For Each Module, Define
+
+### State Machine Structure
+- Textual diagram of all states and transitions
+
+### Data Flow
+- Props, events, and API communication patterns
+
+### Error Management Strategy
+- All error states and user-facing messages
+
+### Loading Behavior
+- Skeleton states, spinners, progressive loading
+
+### Empty State UX
+- What the user sees before data is populated
+
+### Edge Case Handling
+- Boundary conditions, timeouts, network failures
+
+## Output Format
+
+Generate a React component architecture outline including:
+- Hooks and handlers
+- Structural logic (not full implementation)
+
+## Output Goal
+
+This output will inform the interactive prototype built within Figma Make. It should be detailed enough for a developer to implement directly from the spec.