spirewise 1.6.0 → 1.6.3

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++;
@@ -312,6 +358,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,7 +382,11 @@ 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}`,

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.0",
-  "description": "Installable Agent Skills for copywriting (F6S & LinkedIn company pages) for GitHub Copilot, Claude Code, and Cursor.",
+  "version": "1.6.3",
+  "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,16 +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** 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** — 1080×1080 PNG, **solid background**
-  (primary/white/black/other, no transparency or gradient), a wordmark/lettermark/
-  combination mark (not an SVG/UI icon or emoji), saved in the product's folder.
+- Each product gets a **proper designed logo MARK** — 1080×1080 PNG, **mark/symbol
+  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

@@ -2,14 +2,17 @@
 name: nvidia-product-inventor
 description: >-
   Read a startup's existing idea/notes files and invent 3–6 concrete PRODUCTS
-  (not marketing copy) engineered to fit NVIDIA Inception preferences. Each product
-  gets a short brandable name (4–10 letters) and an explicit NVIDIA stack —
-  physical/compute hardware (GPUs, Jetson, DGX…) first, then SDKs, then software.
-  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 (preference levers) and nvidia-inception-starter
-  (acceptance lens). Products only — no website/landing copy.
+  (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 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 (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
+  only — no website/landing copy.
 ---
 
 # NVIDIA Product Inventor
@@ -27,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*`,
@@ -35,10 +89,28 @@ 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:
+- Same **industry/vertical**, same **category**, same **core idea/problem space**,
+  same **target users**.
+- Do **not** invent new categories, jump to a different industry, or generate
+  random/unrelated products. No "while we're at it" pivots.
+- The 3–6 products are **variations, components, tiers, or adjacent features of
+  the one idea** — different angles on the same thing, not different businesses.
+- If a concept only works by leaving the startup's space, drop it.
+- State the locked space at the top of `_overview.md` and make every product
+  visibly trace back to it.
 
 Generate **between 3 and 6** product concepts that each:
-- Solve a sharp, real problem within the startup's domain.
+- Solve a sharp, real problem **within the startup's locked domain** (same idea,
+  same industry, same category).
 - **Require GPU/accelerated compute** to exist (a must-have, not nice-to-have).
 - Lean into **physical / edge / agentic AI** where credible.
 - Have a defensible moat (proprietary data/model/hardware or NVIDIA integration).
@@ -80,6 +152,9 @@ Letters: <n> (must be 4–10)
 Tagline: <one line, what it is>
 Generated: <YYYY-MM-DD>
 
+## Same-space link
+<one line: how this product is the SAME industry/category/core idea as the startup>
+
 ## Problem
 ## Target user
 ## What it does (product, not marketing)
@@ -97,71 +172,103 @@ 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                             (see logo-brief.md + <ProductName>-logo-1080x1080.png)
+## Logo (mark only)              (see logo-brief.md + <ProductName>-logo-1080x1080.png)
 ## Open questions / [UNKNOWN]
 ```
 
-3. Also write `products_raw/_overview.md` listing every product: name, letter
-   count, one-liner, and primary NVIDIA hardware.
+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, 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)
 
-Every product gets a **real, designed brand logo** — not an SVG icon, UI/material
-icon, emoji, or clip-art glyph. Treat it like a brand identity deliverable.
+## Logo MARK for each product (required)
+
+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 logos in the product's space; note the visual
-  conventions, then design something distinct (don't copy).
-- Choose a logo type that fits the short name: **wordmark** (the full name in
-  custom-styled type), **lettermark/monogram** (initials), or **combination mark**
-  (a simple custom symbol + the name). Coherent, ownable, memorable.
-- Define a tiny brand spec: palette (hex), typography style, and the mark concept.
+- 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 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**.
 - **Solid background** — a single flat color with NO transparency and NO gradient.
   Use the brand **primary color**, or white, or black, or another solid color that
   gives strong contrast with the mark. State the exact bg hex in the brief.
-- The logo must be a proper logo (typographic wordmark/lettermark/combination
-  mark), centered with safe padding — not a tiny icon on a big canvas.
+- **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. 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: logo type, concept,
-  background hex, foreground/accent hex, 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* (specify: wordmark/lettermark, the exact name, color
-   palette, solid background, flat vector-style, no photographic texture), then
-   ensure the saved file is a 1080×1080 PNG on a solid background.
-2. **Fallback (always works):** render a deliberate typographic logo
-   programmatically — e.g. Python + Pillow — drawing the wordmark/monogram in a
-   chosen font and color on a solid-color 1080×1080 canvas, with optional simple
-   geometric accent. This must look designed (kerning, weight, composition), not
-   like a stock icon. Verify dimensions and that the background is fully solid.
-
-Do **not** ship: transparent PNGs, gradients, generic icon-font glyphs, stock
-emoji, or screenshots. One clean branded logo per product.
+   *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 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: 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.
 
 ## Verification checklist (run before finishing)
 
-1. Read the existing idea files (and reflected the founder's domain).
-2. `products_raw/` exists with **3–6** product subfolders, each with `product.md`.
-3. Every product name is **4–10 letters, letters only**, and matches its folder.
-4. Each product lists NVIDIA hardware (GPU/physical) first, then SDKs, then software.
-5. Each product justifies why GPU/accelerated compute is essential.
-6. `products_raw/_overview.md` summarizes all products.
-7. Every product folder has a **1080×1080 PNG logo on a solid (non-transparent,
-   non-gradient) background**, plus `logo-brief.md` — a real wordmark/lettermark/
-   combination mark, not an SVG/UI icon or emoji. Verify file dimensions.
-8. No marketing/website copy; unknowns marked `[UNKNOWN]`, not invented.
+1. Read the existing idea files; locked the startup's industry, category, core idea.
+2. **All 3–6 products stay in that same space** — no new categories or unrelated
+   ideas — and each `product.md` has a "Same-space link" tracing back to it.
+3. `products_raw/` exists with **3–6** product subfolders, each with `product.md`.
+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. **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 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.

package/skills/nvidia-startup-idea-founder/README.md

@@ -0,0 +1,36 @@
+# NVIDIA Startup Idea Founder
+
+A **founder-in-residence** skill for NVIDIA Inception. It **crawls live signals**
+— Requests for Startups (RFS), NVIDIA stated priorities, NVentures investments,
+and the most recently funded / newly accepted Inception startups — then **invents
+brand-new startup ideas** at the intersection of those signals, each engineered
+to clear eligibility and hit a **10/10 acceptance chance**.
+
+## What it produces
+
+Writes to an `nvidia-inception/` folder in the project root:
+
+- `rfs-research.md` — crawl digest: ranked hot themes, recently funded/accepted
+  startups (with sources + dates), common acceptance patterns, and white space.
+- `eligibility.md` — the NVIDIA Inception eligibility checklist + go/no-go gate.
+- `startup-ideas/_index.md` — locked themes + a table of every 10/10 idea.
+- `startup-ideas/<IdeaName>.md` — **one full file per idea** (4–10 letter name)
+  with problem, deep-tech solution, GPU-essential rationale, moat, market, NVIDIA
+  stack, eligibility fit, and an **Acceptance Chance Scorecard summing to 10/10**.
+
+## How it works
+
+1. **Crawl** NVIDIA RFS/priorities and recently funded/accepted Inception
+   startups (last 6–12 months), citing dated source URLs.
+2. **Lock eligibility** (incorporated, <10yr, ≥1 dev, website, business email, AI
+   product, no excluded categories).
+3. **Invent 3–6 ideas** at the intersection of a hot RFS theme and a recently
+   funded analog, attacking distinct white space — each scored to **10/10
+   acceptance** or redesigned/dropped.
+
+## Sibling skills
+
+Found the idea here → elevate with `nvidia-inception-idea-booster` → score with
+`nvidia-inception-starter` → turn into products with `nvidia-product-inventor`.
+
+See `SKILL.md` for the full method, output templates, and the 10/10 gate.