spirewise 1.6.2 → 1.7.0

package/README.md

@@ -104,9 +104,25 @@ tidied up, and anything already absent is reported as skipped.
 | `nvidia-inception-starter` | `nvidia-inception/inception-readiness-report.md` | Scored NVIDIA Inception readiness audit + 90-day plan |
 | `nvidia-inception-idea-booster` | `nvidia-inception/elevated-idea.md` | Reads your idea files and elevates them to NVIDIA's preferences |
 | `nvidia-product-inventor` | `products_raw/<Product>/product.md` | Invents 3–6 GPU-essential products (4–10 letter names) from your idea |
+| `nvidia-startup-idea-founder` | `nvidia-inception/startup-ideas/<Idea>.md` | Crawls NVIDIA RFS + recently funded/accepted Inception startups and invents 10/10-acceptance startup ideas |
+| `website-design-skills/01-proof` … `35-jasper` | `websites/<NN-slug>/` | **35 Website Design System Architect skills**, each modeled on a real, live-scraped SaaS site — generates a production-grade HTML/CSS/JS site with that brand's tokens, components, and pages |
 
-Each skill keeps **every field below** the platform's character limit (with ~10%
-headroom) and verifies counts before finishing.
+The copywriting skills keep **every field below** the platform's character limit
+(with ~10% headroom) and verify counts before finishing.
+
+### Website-design skills (grouped)
+
+The 35 website-design skills live in `skills/website-design-skills/` as numbered
+folders (`01-proof` … `35-jasper`). They are discovered automatically and can be
+installed by their **short leaf name** or full path:
+
+```bash
+npx spirewise -s 01-proof -a claude --workspace          # short name
+npx spirewise -s website-design-skills/35-jasper -a cursor  # full path
+```
+
+Each installs into the agent's folder as `NN-slug` (e.g. `.claude/skills/01-proof`).
+See `skills/website-design-skills/README.md` for the full index.
 
 ## Usage after install
 

package/bin/cli.js

@@ -92,15 +92,59 @@ function resolveTarget(agent, scope) {
   return scope === 'project' ? path.resolve(process.cwd(), rel) : path.resolve(expandHome(rel));
 }
 
+// Recursively find every skill folder (a dir containing SKILL.md) at any depth
+// under skills/. Skill ids are POSIX-style relative paths, e.g.
+// "f6s-copywriting" or "website-design-skills/01-proof".
+function walkSkills(dir, baseDir, out) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue;
+    const abs = path.join(dir, entry.name);
+    if (fs.existsSync(path.join(abs, 'SKILL.md'))) {
+      out.push(path.relative(baseDir, abs).split(path.sep).join('/'));
+    } else {
+      walkSkills(abs, baseDir, out); // descend into grouping folders
+    }
+  }
+}
 function availableSkills() {
   if (!fs.existsSync(SKILLS_DIR)) return [];
-  return fs.readdirSync(SKILLS_DIR, { withFileTypes: true })
-    .filter((d) => d.isDirectory() && fs.existsSync(path.join(SKILLS_DIR, d.name, 'SKILL.md')))
-    .map((d) => d.name).sort();
+  const out = [];
+  walkSkills(SKILLS_DIR, SKILLS_DIR, out);
+  return out.sort();
+}
+
+// Source dir and leaf base name for a skill id.
+const skillSrc = (id) => path.join(SKILLS_DIR, ...id.split('/'));
+const skillBase = (id) => id.split('/').pop();
+
+// Map every skill id -> the folder/file name it installs as. Leaf basename is
+// used when unique; colliding basenames fall back to the flattened path so two
+// skills never overwrite each other.
+function buildInstallNames(ids) {
+  const counts = Object.create(null);
+  for (const id of ids) { const b = skillBase(id); counts[b] = (counts[b] || 0) + 1; }
+  const map = new Map();
+  for (const id of ids) {
+    const b = skillBase(id);
+    map.set(id, counts[b] > 1 ? id.split('/').join('-') : b);
+  }
+  return map;
+}
+let NAME_BY_ID = new Map();
+const installName = (id) => NAME_BY_ID.get(id) || skillBase(id);
+
+// Resolve a user-supplied token to a full skill id. Accepts the full path
+// ("website-design-skills/01-proof") or the unique leaf name ("01-proof").
+function resolveSkillToken(tok, available) {
+  if (available.includes(tok)) return tok;
+  const matches = available.filter((id) => skillBase(id) === tok);
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) die(`Ambiguous skill '${tok}': matches ${matches.join(', ')}. Use the full path.`);
+  return null;
 }
 
 function readSkill(name) {
-  const raw = fs.readFileSync(path.join(SKILLS_DIR, name, 'SKILL.md'), 'utf8');
+  const raw = fs.readFileSync(path.join(skillSrc(name), 'SKILL.md'), 'utf8');
   let description = name, body = raw;
   const m = raw.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
   if (m) {
@@ -130,14 +174,15 @@ function installToAgent(agentKey, agent, scope, skills) {
   const targetDir = resolveTarget(agent, scope);
   fs.mkdirSync(targetDir, { recursive: true });
   for (const skill of skills) {
+    const name = installName(skill);
     if (agent.format === 'skill') {
-      const dest = path.join(targetDir, skill);
-      copyDir(path.join(SKILLS_DIR, skill), dest);
+      const dest = path.join(targetDir, name);
+      copyDir(skillSrc(skill), dest);
       console.log(`      ${paint(RAW.green, '✓')} ${paint(RAW.bold, agent.label)} ${c.dim}(${scope === 'project' ? 'workspace' : scope})${c.reset} ${skill} ${c.dim}→ ${dest}${c.reset}`);
     } else {
       const { description, body } = readSkill(skill);
       const front = `---\ndescription: ${description}\nalwaysApply: false\n---\n\n`;
-      const file = path.join(targetDir, skill + (agent.ext || '.md'));
+      const file = path.join(targetDir, name + (agent.ext || '.md'));
       fs.writeFileSync(file, front + body);
       console.log(`      ${paint(RAW.green, '✓')} ${paint(RAW.bold, agent.label)} ${c.dim}(${scope === 'project' ? 'workspace' : scope})${c.reset} ${skill} ${c.dim}→ ${file}${c.reset}`);
     }
@@ -150,9 +195,10 @@ function removeFromAgent(agentKey, agent, scope, skills) {
   const tag = scope === 'project' ? 'workspace' : scope;
   let removed = 0;
   for (const skill of skills) {
+    const name = installName(skill);
     const target = agent.format === 'skill'
-      ? path.join(targetDir, skill)
-      : path.join(targetDir, skill + (agent.ext || '.md'));
+      ? path.join(targetDir, name)
+      : path.join(targetDir, name + (agent.ext || '.md'));
     if (fs.existsSync(target)) {
       fs.rmSync(target, { recursive: true, force: true });
       removed++;
@@ -177,7 +223,7 @@ function box(lines) {
 }
 
 // --- Interactive full-width selector ---------------------------------------
-function interactiveSelect({ title, subtitle, items, multi = true, preselected = [] }) {
+function interactiveSelect({ title, subtitle, items, multi = true, preselected = [], pageSize = 5 }) {
   return new Promise((resolve) => {
     const stdin = process.stdin, stdout = process.stdout;
     if (!stdin.isTTY) { resolve(null); return; }
@@ -197,17 +243,34 @@ function interactiveSelect({ title, subtitle, items, multi = true, preselected =
     };
 
     function render() {
+      // Windowed viewport: show at most `pageSize` rows and keep the cursor
+      // centered so long lists (e.g. skills) scroll smoothly with up/down.
+      const PAGE = Math.min(pageSize, items.length);
+      const half = Math.floor(PAGE / 2);
+      let start = index - half;
+      if (start < 0) start = 0;
+      if (start > items.length - PAGE) start = items.length - PAGE;
+      const end = start + PAGE;
+
       const lines = ['', bar(title)];
       if (subtitle) lines.push(paint(RAW.dim, '  ' + subtitle));
+      if (items.length > PAGE) {
+        const above = start > 0 ? '▲ more' : '      ';
+        lines.push(paint(RAW.dim, `  ${above}   ${index + 1}/${items.length}`));
+      }
       lines.push('');
-      items.forEach((it, i) => {
+      for (let i = start; i < end; i++) {
+        const it = items[i];
         const cur = i === index ? paint(RAW.cyan, '❯') : ' ';
         const mark = multi ? (selected.has(i) ? paint(RAW.green, '◉') : paint(RAW.dim, '◯'))
                            : (i === index ? paint(RAW.green, '◉') : paint(RAW.dim, '◯'));
         const label = i === index ? paint(RAW.bold, it.label) : it.label;
         const hint = it.hint ? paint(RAW.dim, '  ' + it.hint) : '';
         lines.push(`   ${cur} ${mark}  ${label}${hint}`);
-      });
+      }
+      if (items.length > PAGE) {
+        lines.push(paint(RAW.dim, `  ${end < items.length ? '▼ more' : '      '}`));
+      }
       lines.push('');
       lines.push(paint(RAW.dim, '  ' + (multi
         ? '↑/↓ move · space toggle · a all/none · enter confirm · esc cancel'
@@ -312,6 +375,7 @@ async function main() {
 
   const available = availableSkills();
   if (available.length === 0) die('No skills found in package.');
+  NAME_BY_ID = buildInstallNames(available);
 
   if (command === 'list') {
     info('Available skills:'); available.forEach((s) => console.log('  - ' + s)); return;
@@ -335,13 +399,17 @@ async function main() {
   // 1) SKILLS
   let skills = o.skills;
   if (skills) {
-    for (const s of skills) if (!available.includes(s)) die(`Unknown skill '${s}'. Run "spirewise list".`);
+    skills = skills.map((s) => {
+      const id = resolveSkillToken(s, available);
+      if (!id) die(`Unknown skill '${s}'. Run "spirewise list".`);
+      return id;
+    });
   } else if (tty) {
     skills = await interactiveSelect({
       title: `Step 1/3 · Select skills to ${verb}`,
       subtitle: action === 'remove' ? 'These will be deleted from the chosen agents' : 'Copy templates to install into your agents',
       items: available.map((s) => ({ value: s, label: s, hint: skillHint(s) })),
-      multi: true, preselected: available,
+      multi: true, preselected: [],
     });
     if (skills === null) die('Cancelled.');
     if (!skills.length) die('No skills selected.');
@@ -356,7 +424,7 @@ async function main() {
       title: `Step 2/3 · Select agents`,
       subtitle: action === 'remove' ? 'Skills are removed from each agent’s folder' : 'Each agent gets the skills in its own folder + format',
       items: Object.entries(AGENTS).map(([k, a]) => ({ value: k, label: a.label, hint: `(${k}) · ${a.format}` })),
-      multi: true, preselected: Object.keys(AGENTS),
+      multi: true, preselected: [],
     });
     if (agentKeys === null) die('Cancelled.');
     if (!agentKeys.length) die('No agents selected.');
@@ -373,7 +441,7 @@ async function main() {
         { value: 'global',  label: 'Global',    hint: 'your home folders — applies to all projects' },
         { value: 'both',    label: 'Both',      hint: 'workspace + global' },
       ],
-      multi: false, preselected: ['project'],
+      multi: false, preselected: [],
     });
     if (scope === null) die('Cancelled.');
   } else if (!scope) { warn('No terminal; defaulting scope to "workspace".'); scope = 'project'; }

package/install.sh

@@ -101,23 +101,40 @@ ensure_skills_dir() {
 }
 
 list_remote_skills() {
-  curl -fsSL "$API_BASE" \
-    | grep '"name"' | sed -E 's/.*"name": *"([^"]+)".*/\1/' \
-    | while read -r n; do
-        curl -fsI "${RAW_BASE}/${SKILLS_SUBDIR}/${n}/SKILL.md" >/dev/null 2>&1 && echo "$n"
-      done
+  # Walk the full git tree and surface every "<id>/SKILL.md" under skills/.
+  curl -fsSL "https://api.github.com/repos/${REPO_OWNER}/${REPO_NAME}/git/trees/${REPO_BRANCH}?recursive=1" \
+    | grep -oE "\"path\": *\"${SKILLS_SUBDIR}/[^\"]+/SKILL.md\"" \
+    | sed -E "s/.*\"${SKILLS_SUBDIR}\/(.+)\/SKILL.md\"/\1/" \
+    | sort -u
 }
 
 available_skills() {
   if [[ -n "$LOCAL_SKILLS_DIR" ]]; then
-    find "$LOCAL_SKILLS_DIR" -maxdepth 2 -name SKILL.md -print0 \
-      | xargs -0 -n1 dirname | xargs -n1 basename | sort
+    # Any folder containing SKILL.md, at any depth, as a relative id.
+    find "$LOCAL_SKILLS_DIR" -name SKILL.md -print \
+      | sed -e "s#^${LOCAL_SKILLS_DIR}/##" -e 's#/SKILL.md$##' \
+      | sort
   else
     list_remote_skills | sort
   fi
 }
 
-# Fetch a single SKILL.md into $BASE/<skill>/SKILL.md when remote.
+# Leaf base name a skill id installs as (e.g. website-design-skills/01-proof -> 01-proof).
+skill_base() { printf '%s' "${1##*/}"; }
+
+# Resolve a user token to a full id: exact id, else unique leaf-name match.
+resolve_skill_token() {
+  local tok="$1" id match count=0
+  for id in "${AVAILABLE[@]}"; do [[ "$id" == "$tok" ]] && { printf '%s' "$id"; return 0; }; done
+  for id in "${AVAILABLE[@]}"; do
+    if [[ "$(skill_base "$id")" == "$tok" ]]; then match="$id"; count=$((count+1)); fi
+  done
+  [[ $count -eq 1 ]] && { printf '%s' "$match"; return 0; }
+  [[ $count -gt 1 ]] && die "Ambiguous skill '$tok'. Use the full path."
+  return 1
+}
+
+# Fetch a single SKILL.md into $BASE/<id>/SKILL.md when remote.
 fetch_skill() {
   local skill="$1" base="$2"
   [[ -n "$LOCAL_SKILLS_DIR" ]] && return 0
@@ -162,16 +179,17 @@ resolve_dir() {
 install_for_agent() {
   local key="$1" label="$2" fmt="$3" ext="$4" dir="$5" scope="$6" base="$7"; shift 7
   local skills=("$@")
-  local s
+  local s iname
   if [[ "$MODE" == "remove" ]]; then
     for s in "${skills[@]}"; do
+      iname="$(skill_base "$s")"
       local target
-      if [[ "$fmt" == "skill" ]]; then target="$dir/$s"; else target="$dir/$s$ext"; fi
+      if [[ "$fmt" == "skill" ]]; then target="$dir/$iname"; else target="$dir/$iname$ext"; fi
       if [[ -e "$target" ]]; then
         rm -rf "$target"; REMOVED=$((REMOVED+1))
-        substep "$label ($scope) $s removed <- $target"
+        substep "$label ($scope) $iname removed <- $target"
       else
-        substep "$label ($scope) $s — not found, skipped"
+        substep "$label ($scope) $iname — not found, skipped"
       fi
     done
     [[ -d "$dir" ]] && rmdir "$dir" 2>/dev/null || true
@@ -179,17 +197,18 @@ install_for_agent() {
   fi
   mkdir -p "$dir"
   for s in "${skills[@]}"; do
+    iname="$(skill_base "$s")"
     fetch_skill "$s" "$base"
     if [[ "$fmt" == "skill" ]]; then
-      mkdir -p "$dir/$s"
-      cp -R "$base/$s/." "$dir/$s/"
-      substep "$label ($scope) $s -> $dir/$s"
+      mkdir -p "$dir/$iname"
+      cp -R "$base/$s/." "$dir/$iname/"
+      substep "$label ($scope) $iname -> $dir/$iname"
     else
       local desc body file
       desc="$(skill_description "$base/$s/SKILL.md")"
-      file="$dir/$s$ext"
+      file="$dir/$iname$ext"
       { printf -- '---\ndescription: %s\nalwaysApply: false\n---\n\n' "$desc"; skill_body "$base/$s/SKILL.md"; } >"$file"
-      substep "$label ($scope) $s -> $file"
+      substep "$label ($scope) $iname -> $file"
     fi
   done
 }
@@ -237,11 +256,16 @@ banner
 
 # Step 1: skills (default all).
 step 1 "Scanning available skills"
-[[ ${#SELECTED[@]} -eq 0 ]] && SELECTED=("${AVAILABLE[@]}")
-for s in "${SELECTED[@]}"; do
-  found=false; for a in "${AVAILABLE[@]}"; do [[ "$s" == "$a" ]] && found=true && break; done
-  $found || die "Unknown skill '$s'. Use --list."
-done
+if [[ ${#SELECTED[@]} -eq 0 ]]; then
+  SELECTED=("${AVAILABLE[@]}")
+else
+  RESOLVED=()
+  for s in "${SELECTED[@]}"; do
+    id="$(resolve_skill_token "$s")" || die "Unknown skill '$s'. Use --list."
+    RESOLVED+=("$id")
+  done
+  SELECTED=("${RESOLVED[@]}")
+fi
 substep "${#SELECTED[@]} skill(s): ${SELECTED[*]}"
 
 # Step 2: agents

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "spirewise",
-  "version": "1.6.2",
-  "description": "Installable Agent Skills for copywriting (F6S & LinkedIn company pages) for GitHub Copilot, Claude Code, and Cursor.",
+  "version": "1.7.0",
+  "description": "Installable Agent Skills for GitHub Copilot, Claude Code, and Cursor — copywriting (F6S & LinkedIn), NVIDIA Inception tooling, and 35 website design-system architect skills modeled on real SaaS sites.",
   "bin": {
     "spirewise": "bin/cli.js"
   },
@@ -19,6 +19,9 @@
     "copywriting",
     "f6s",
     "linkedin",
+    "nvidia-inception",
+    "website-design",
+    "design-system",
     "github-copilot",
     "claude-code",
     "cursor",

package/skills/README.md

@@ -12,6 +12,8 @@ ready-to-paste copy for company profile pages, with strict character-limit safet
 | `nvidia-inception-starter` | `nvidia-inception/inception-readiness-report.md` | Scored NVIDIA Inception readiness audit + 90-day plan |
 | `nvidia-inception-idea-booster` | `nvidia-inception/elevated-idea.md` | Reads your idea files and elevates them to NVIDIA's preferences |
 | `nvidia-product-inventor` | `products_raw/<Product>/product.md` | Invents 3–6 GPU-essential products (4–10 letter names) from your idea |
+| `nvidia-startup-idea-founder` | `nvidia-inception/startup-ideas/<Idea>.md` | Crawls NVIDIA RFS + recently funded/accepted Inception startups and invents 10/10-acceptance startup ideas |
+| `website-design-skills/01-proof` … `35-jasper` | `websites/<NN-slug>/` | 35 design-system skills, each modeled on a real SaaS site (15+ pages, products + per-product pages) |
 
 Each skill writes one plain-text file and keeps **every field below** the
 platform's character limit (with ~10% headroom).

package/skills/nvidia-product-inventor/README.md

@@ -51,20 +51,29 @@ products_raw/
 Each `product.md` covers the problem, what it does, **why GPU compute is
 essential**, the NVIDIA stack (hardware → SDKs → software), physical/edge angle,
 moat, market, Inception fit, and MVP scope. Each product also ships a **real
-1080×1080 PNG logo mark** (symbol only, centered) on a solid background.
+1080×1080 PNG logo mark** (abstract symbol only, no letters, centered) on a solid background.
 
 ## Rules it enforces
 
 - **Same space only** — all products share the startup's industry, category, core
   idea, and users (variations/components of the one idea), never new categories or
   unrelated businesses.
+- **Dual 10/10 gate** — every product must self-score **10/10 on NVIDIA Inception
+  approval fit AND 10/10 on same-space fit** (both recorded in `product.md` and
+  `_overview.md`); redesign or discard anything below 10 on either axis.
+- **Research-backed approval criteria** — products are engineered to the qualities
+  NVIDIA-approved startups share (deep-tech & GPU-essential core, authentic NVIDIA
+  platform alignment, physical/agentic AI lean, defensible moat, real market +
+  scalability) and trip **zero disqualifiers** (no AI wrappers, consulting, crypto,
+  or reseller plays).
 - **3–6 products**, each in its own folder under `products_raw/`.
 - Product names are **4–10 letters, letters only**, brandable; folder name = product name.
 - NVIDIA stack ordered **physical/GPU first**, then SDKs, then software.
 - Every product must genuinely need accelerated compute (no AI wrappers).
 - Each product gets a **proper designed logo MARK** — 1080×1080 PNG, **mark/symbol
-  only and center-aligned** (no full wordmark or name text), **solid background**
-  (primary/white/black/other, no transparency or gradient), a monogram or custom
-  brand symbol (not an SVG/UI icon or emoji), saved in the product's folder.
+  only and center-aligned** (no full wordmark or name text, **no letters,
+  initials, or monogram**), **solid background** (primary/white/black/other, no
+  transparency or gradient), a letter-free custom brand symbol (not an SVG/UI icon
+  or emoji), saved in the product's folder.
 
 See `SKILL.md` for the full method and the per-product template.

package/skills/nvidia-product-inventor/SKILL.md

@@ -4,10 +4,11 @@ description: >-
   Read a startup's existing idea/notes files and invent 3–6 concrete PRODUCTS
   (not marketing copy) that all stay in the SAME industry, category, and core idea
   as the startup — variations/components of the one idea, never new categories.
-  Each product is engineered to fit NVIDIA Inception preferences, gets a short
+  Each product is engineered to score a perfect 10/10 on NVIDIA Inception
+  approval fit AND 10/10 on same-space alignment, gets a short
   brandable name (4–10 letters), an explicit NVIDIA stack (physical/compute
   hardware like GPUs first, then SDKs, then software), and a real 1080×1080 PNG
-  logo MARK (symbol only, centered, no wordmark) on a solid background. Use when the user asks to "invent products", "ideate
+  logo MARK (abstract symbol only — no letters, no wordmark, centered) on a solid background. Use when the user asks to "invent products", "ideate
   products for NVIDIA", "what should we build for Inception", or "turn our idea
   into products". Writes a `products_raw/` folder with one subfolder per product.
   Builds on nvidia-inception-idea-booster and nvidia-inception-starter. Products
@@ -29,6 +30,57 @@ marketing copy.
   (AI strength, technical innovation, NVIDIA alignment, market, moat). Keep only
   products that would plausibly score well; discard weak/"AI-wrapper" ones.
 
+## What NVIDIA Inception actually approves (research-backed)
+
+NVIDIA Inception is free, non-dilutive, rolling-admission, and **industry-agnostic
+within emerging/accelerated-computing tech**. Engineer every product so it would
+read as an obvious **accept** to a reviewer. Approved startups consistently show:
+
+1. **Deep-tech, GPU-essential core.** The product solves a hard technical problem
+   (computer vision, LLMs/agents, RL, simulation, graphics, robotics, genomics,
+   edge AI) that **substantially benefits from — or is impossible without — GPU
+   acceleration**. State plainly why it can't be built (or would be far worse) on
+   CPUs alone.
+2. **Authentic NVIDIA-platform alignment.** Concrete, credible use of NVIDIA
+   hardware + SDKs (CUDA, TensorRT, Triton/NIM, Isaac, Omniverse, Metropolis,
+   Holoscan, NeMo, Riva, RAPIDS…). The product should **drive demand for NVIDIA
+   compute** and act as a reference workload.
+3. **Physical AI / Agentic AI lean.** Robotics, autonomous systems, industrial
+   automation, digital twins, embodied AI (physical AI) and/or autonomous
+   decision-making agents/copilots (agentic AI). NVIDIA strongly favors these.
+4. **Defensible moat.** Proprietary IP, unique/large proprietary datasets, deep
+   technical barriers, or hardware integration — not easily replicated.
+5. **Real market + scalability.** Clear customer ROI, a sharp wedge, and a model
+   that scales on GPU cloud or edge fleets. Pilots/traction are a plus to note.
+6. **Research-to-product trajectory.** Credible technical depth (papers/SOTA
+   methods) paired with a concrete, buildable product — not a science project.
+
+### Hard disqualifiers — never generate products that read as these
+- **AI wrappers / thin API resellers** with no GPU-essential core or moat.
+- **Consulting / outsourced-dev** offerings (sell a product, not services).
+- **Crypto/mining/trading**, pure **cloud-reselling**, or generic
+  **reseller/distributor** plays.
+- Anything where the GPU is a "nice-to-have," not a must-have.
+
+## The dual 10/10 bar (mandatory gate)
+
+Every shipped product MUST score a self-assessed **10/10 on BOTH** axes — this is
+a hard gate, not an average:
+
+- **Inception Approval Fit (target 10/10):** maximally hits the six approval
+  qualities above, trips **zero** disqualifiers, and would plausibly land at the
+  top of the `nvidia-inception-starter` acceptance score.
+- **Same-Space Fit (target 10/10):** stays entirely inside the startup's locked
+  industry, category, core idea, and target users (see Step 2) — a variation,
+  component, tier, or adjacent feature of the one idea, never a new business.
+
+Rules:
+- If a candidate scores **< 10 on either axis, redesign it until both hit 10, or
+  discard it.** Do not ship 8s or "good enough" products. Quality over quantity —
+  it is better to ship 3 dual-10/10 products than 6 mediocre ones.
+- Record both scores (with a one-line justification each) in every `product.md`
+  and in `_overview.md`. Never inflate a score to be nice; be a tough reviewer.
+
 ## Step 1 — Read the existing idea
 
 Discover and read the startup files in the project: `idea*`, `README*`, `pitch*`,
@@ -37,10 +89,12 @@ Discover and read the startup files in the project: `idea*`, `README*`, `pitch*`
 If too little exists, ask 3–5 focused questions first. Mark gaps `[UNKNOWN]` —
 never fabricate. Stay anchored to the founder's domain and intent.
 
-## Step 2 — Invent 3–6 products
-
 ## Step 2 — Invent 3–6 products (stay in the SAME space)
 
+**Same space means: every product is ONLY in the startup's same category /
+industry and directly tied to its main idea — never random categories,
+industries, or unrelated products.**
+
 **Hard constraint — same space only.** Before inventing, lock the startup's
 **industry, category, and core idea** from Step 1. Every product MUST stay inside
 that exact space:
@@ -118,6 +172,9 @@ Generated: <YYYY-MM-DD>
 ## Defensibility / moat
 ## Market & wedge
 ## Inception fit                    (1–2 lines: why this scores well)
+## Scorecard (must be 10/10 on both)
+- Inception Approval Fit: 10/10 — <one-line justification vs. the six approval qualities>
+- Same-Space Fit: 10/10 — <one-line justification it stays in the locked space>
 ## Build notes / MVP scope
 ## Logo (mark only)              (see logo-brief.md + <ProductName>-logo-1080x1080.png)
 ## Open questions / [UNKNOWN]
@@ -125,26 +182,29 @@ Generated: <YYYY-MM-DD>
 
 3. Also write `products_raw/_overview.md` starting with the **locked space**
    (industry, category, core idea, target users), then list every product: name,
-   letter count, one-liner, primary NVIDIA hardware, and its same-space link.
+   letter count, one-liner, primary NVIDIA hardware, its same-space link, and both
+   scores (Inception Approval Fit 10/10 + Same-Space Fit 10/10). Confirm every
+   listed product is a dual 10/10 — drop any that isn't.
 
 ## Logo for each product (required)
 
 ## Logo MARK for each product (required)
 
-Every product gets a **real, designed brand logo MARK** — the symbol only, not
-the full logo. Do **not** include the full product name as a wordmark, no
-tagline, no lockup. Just the **mark**, **center-aligned** on the canvas. It must
-be a proper designed brand mark — not an SVG icon, UI/material icon, emoji, or
-clip-art glyph.
+Every product gets a **real, designed brand logo MARK** — a **custom abstract
+symbol only**, not the full logo. Do **not** include any letters, initials,
+monogram, or lettermark; do **not** include the full product name as a wordmark,
+no tagline, no lockup. Just the **symbol mark**, **center-aligned** on the
+canvas. It must be a proper designed brand mark — not an SVG icon, UI/material
+icon, emoji, or clip-art glyph.
 
 ### Design (research first)
 - Briefly research 3–5 reference brand marks in the product's space; note the
   visual conventions, then design something distinct (don't copy).
-- The mark is **one of**: a **monogram/lettermark** (1–2 brand initials drawn as a
-  custom mark) or a **distinctive custom brand symbol** tied to the concept.
-  Ownable, memorable, simple, and scalable.
-- Define a tiny brand spec: palette (hex), the mark concept, and (if a monogram)
-  the typographic treatment.
+- The mark must be a **distinctive custom brand symbol** tied to the concept —
+  purely abstract/pictorial, containing **no letters or initials**. Ownable,
+  memorable, simple, and scalable.
+- Define a tiny brand spec: palette (hex) and the mark concept (the symbol's
+  meaning and geometry). No typography — the mark contains no text.
 
 ### Hard output rules
 - Format **PNG**, exactly **1080 × 1080 px**.
@@ -153,38 +213,42 @@ clip-art glyph.
   gives strong contrast with the mark. State the exact bg hex in the brief.
 - **Mark only**, **center-aligned** both horizontally and vertically, sized large
   with balanced safe padding — not a tiny icon on a big canvas, and not the full
-  name spelled out.
+  name spelled out. The mark must contain **no letters or initials**.
 - Save it **inside that product's folder**:
   `products_raw/<ProductName>/<ProductName>-logo-1080x1080.png`
-- Also write `products_raw/<ProductName>/logo-brief.md` with: mark type
-  (monogram vs. symbol), concept, background hex, mark/accent hex, any typography,
-  and references consulted.
+- Also write `products_raw/<ProductName>/logo-brief.md` with: symbol concept,
+  background hex, mark/accent hex, and references consulted. (No monogram/
+  lettermark option and no typography — the mark is a letter-free symbol.)
 
 ### How to generate it
 1. **Preferred:** if an image-generation tool/model is available, prompt it for a
-   *professional brand logo mark / symbol* (specify: mark/symbol only — no text,
-   no wordmark — the concept, color palette, solid background, flat vector-style,
-   centered, no photographic texture), then ensure the saved file is a 1080×1080
-   PNG on a solid background with the mark centered.
+   *professional brand logo mark / symbol* (specify: abstract symbol only — no
+   letters, no initials, no text, no wordmark — the concept, color palette, solid
+   background, flat vector-style, centered, no photographic texture), then ensure
+   the saved file is a 1080×1080 PNG on a solid background with the mark centered.
 2. **Fallback (always works):** render a deliberate brand mark programmatically —
-   e.g. Python + Pillow — drawing a custom monogram (1–2 initials) or geometric
-   symbol, centered on a solid-color 1080×1080 canvas. This must look designed
-   (composition, weight, balance), not like a stock icon. Verify dimensions, that
-   the mark is centered, and that the background is fully solid.
+   e.g. Python + Pillow — drawing a custom geometric/abstract symbol (no letters
+   or initials), centered on a solid-color 1080×1080 canvas. This must look
+   designed (composition, weight, balance), not like a stock icon. Verify
+   dimensions, that the mark is centered, and that the background is fully solid.
 
-Do **not** ship: full wordmarks/the spelled-out name, taglines, transparent PNGs,
-gradients, generic icon-font glyphs, stock
-emoji, or screenshots. One clean, centered brand **mark** per product.
+Do **not** ship: lettermarks/monograms/initials, full wordmarks/the spelled-out
+name, taglines, transparent PNGs, gradients, generic icon-font glyphs, stock
+emoji, or screenshots. One clean, centered letter-free brand **symbol** per product.
 
 ## Quality bar
 
+- **Dual 10/10 gate.** Every shipped product scores 10/10 on Inception Approval
+  Fit AND 10/10 on Same-Space Fit. Redesign or discard anything below 10 on
+  either axis — quality over quantity.
 - **Same space only.** All products share the startup's industry, category, core
   idea, and users — variations/components/tiers of the one idea, never new
   categories or unrelated businesses.
 - **Products, not copy.** No website/landing/marketing text — concrete product
   concepts and technical plans only.
 - Every product must be GPU-essential and NVIDIA-aligned, with the stack ordered
-  physical → SDK → software.
+  physical → SDK → software, and trip **zero** Inception disqualifiers (no AI
+  wrappers, consulting, crypto, or reseller plays).
 - Names obey the 4–10 letter rule (verified) and folder names match.
 - Stay within the founder's domain; elevate, don't fabricate.
 
@@ -197,9 +261,14 @@ emoji, or screenshots. One clean, centered brand **mark** per product.
 4. Every product name is **4–10 letters, letters only**, and matches its folder.
 5. Each product lists NVIDIA hardware (GPU/physical) first, then SDKs, then software.
 6. Each product justifies why GPU/accelerated compute is essential.
-7. `products_raw/_overview.md` opens with the locked space, then summarizes all products.
-8. Every product folder has a **1080×1080 PNG logo MARK on a solid
+7. **Every product is a dual 10/10** — Inception Approval Fit 10/10 and Same-Space
+   Fit 10/10, both scored with a justification in `product.md` and `_overview.md`,
+   and trips none of the hard disqualifiers (AI wrapper, consulting, crypto, reseller).
+8. `products_raw/_overview.md` opens with the locked space, then summarizes all
+   products with both scores.
+9. Every product folder has a **1080×1080 PNG logo MARK on a solid
    (non-transparent, non-gradient) background**, the **mark centered** with no full
-   wordmark/name text, plus `logo-brief.md` — a real monogram or custom symbol,
-   not an SVG/UI icon or emoji. Verify dimensions and that the mark is centered.
-9. No marketing/website copy; unknowns marked `[UNKNOWN]`, not invented.
+   wordmark/name text and **no letters, initials, or monogram**, plus
+   `logo-brief.md` — a real letter-free custom symbol, not an SVG/UI icon or
+   emoji. Verify dimensions and that the mark is centered.
+10. No marketing/website copy; unknowns marked `[UNKNOWN]`, not invented.