spirewise 1.1.0 → 1.6.0

package/README.md

@@ -81,12 +81,29 @@ npx spirewise agents      # supported agents + their folders
 npx spirewise --help      # all options
 ```
 
+## Uninstall
+
+`remove` (alias `uninstall`) mirrors install — same interactive picker, same
+flags — and deletes the skills cleanly from workspace, global, or both:
+
+```bash
+npx spirewise remove                                  # interactive picker
+npx spirewise remove -sc both                         # pick skills+agents, both
+npx spirewise remove -s f6s-copywriting -a cursor -sc workspace
+```
+
+Skill folders and generated rule files are deleted; now-empty target folders are
+tidied up, and anything already absent is reported as skipped.
+
 ## Skills included
 
 | Skill | Output file | Purpose |
 |-------|-------------|---------|
 | `f6s-copywriting` | `f6s/f6s-profile-copy.txt` | Full F6S startup profile copy |
 | `linkedin-copywriting` | `linkedin copywriting/linkedin-page-copy.txt` | Full LinkedIn Company Page copy |
+| `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 |
 
 Each skill keeps **every field below** the platform's character limit (with ~10%
 headroom) and verifies counts before finishing.

package/bin/cli.js

@@ -144,6 +144,30 @@ function installToAgent(agentKey, agent, scope, skills) {
   }
 }
 
+// Returns the number of items actually removed.
+function removeFromAgent(agentKey, agent, scope, skills) {
+  const targetDir = resolveTarget(agent, scope);
+  const tag = scope === 'project' ? 'workspace' : scope;
+  let removed = 0;
+  for (const skill of skills) {
+    const target = agent.format === 'skill'
+      ? path.join(targetDir, skill)
+      : path.join(targetDir, skill + (agent.ext || '.md'));
+    if (fs.existsSync(target)) {
+      fs.rmSync(target, { recursive: true, force: true });
+      removed++;
+      console.log(`      ${paint(RAW.green, '✓')} ${paint(RAW.bold, agent.label)} ${c.dim}(${tag})${c.reset} ${skill} ${c.dim}removed ← ${target}${c.reset}`);
+    } else {
+      console.log(`      ${paint(RAW.dim, '·')} ${agent.label} ${c.dim}(${tag})${c.reset} ${skill} ${c.dim}— not found, skipped${c.reset}`);
+    }
+  }
+  // Tidy up the now-empty rules/skills dir we may have created.
+  try {
+    if (fs.existsSync(targetDir) && fs.readdirSync(targetDir).length === 0) fs.rmdirSync(targetDir);
+  } catch (_) {}
+  return removed;
+}
+
 function box(lines) {
   const vis = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
   const width = Math.max(...lines.map((l) => vis(l).length));
@@ -253,11 +277,12 @@ function usage() {
 
 Usage:
   spirewise [install] [options]      run interactive picker for anything not set
+  spirewise remove   [options]       uninstall skills (alias: uninstall)
   spirewise list                     list available skills
   spirewise agents                   list supported agents + folders
 
 Options:
-  -s,  --skills <a,b>    skills to install            (default: all / pick)
+  -s,  --skills <a,b>    skills to install/remove     (default: all / pick)
   -a,  --agents <a,b>    agents to target             (default: all / pick)  alias: --agent
   -sc, --scope  <s>      workspace | global | both    (default: pick)
        --workspace | --global | --both   scope shortcuts
@@ -273,15 +298,18 @@ Examples:
   npx spirewise                                  # full interactive picker
   npx spirewise -sc both                         # pick skills+agents, scope=both
   npx spirewise -s f6s-copywriting -a claude,cursor -sc workspace
+  npx spirewise remove -sc both                  # uninstall (pick skills+agents)
 `);
 }
 
 async function main() {
   let argv = process.argv.slice(2);
   let command = 'install';
-  if (['list', 'install', 'agents'].includes(argv[0])) { command = argv[0]; argv = argv.slice(1); }
+  if (['list', 'install', 'agents', 'remove', 'uninstall'].includes(argv[0])) { command = argv[0]; argv = argv.slice(1); }
   else if (argv[0] === '-h' || argv[0] === '--help') { usage(); return; }
 
+  const action = (command === 'remove' || command === 'uninstall') ? 'remove' : 'install';
+
   const available = availableSkills();
   if (available.length === 0) die('No skills found in package.');
 
@@ -300,6 +328,8 @@ async function main() {
 
   const o = parseArgs(argv);
   const tty = process.stdin.isTTY;
+  const verb = action === 'remove' ? 'remove' : 'install';
+  const Verb = action === 'remove' ? 'Remove' : 'Install';
   banner();
 
   // 1) SKILLS
@@ -308,8 +338,8 @@ async function main() {
     for (const s of skills) if (!available.includes(s)) die(`Unknown skill '${s}'. Run "spirewise list".`);
   } else if (tty) {
     skills = await interactiveSelect({
-      title: 'Step 1/3 · Select skills',
-      subtitle: 'Copy templates to install into your agents',
+      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,
     });
@@ -323,8 +353,8 @@ async function main() {
     for (const k of agentKeys) if (!AGENTS[k]) die(`Unknown agent '${k}'. Run "spirewise agents".`);
   } else if (tty) {
     agentKeys = await interactiveSelect({
-      title: 'Step 2/3 · Select agents',
-      subtitle: 'Each agent gets the skills in its own folder + format',
+      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),
     });
@@ -337,7 +367,7 @@ async function main() {
   if (!scope && tty) {
     scope = await interactiveSelect({
       title: 'Step 3/3 · Select scope',
-      subtitle: 'Where should the skills live?',
+      subtitle: action === 'remove' ? 'Where to remove the skills from?' : 'Where should the skills live?',
       items: [
         { value: 'project', label: 'Workspace', hint: 'this folder only — the current project' },
         { value: 'global',  label: 'Global',    hint: 'your home folders — applies to all projects' },
@@ -350,18 +380,30 @@ async function main() {
   if (!['project', 'global', 'both'].includes(scope)) die(`Invalid scope '${scope}'.`);
   const scopes = scope === 'both' ? ['project', 'global'] : [scope];
 
-  // INSTALL
+  // ACTION
   console.log('');
-  info(`Installing ${paint(RAW.bold, String(skills.length))} skill(s) into ${paint(RAW.bold, String(agentKeys.length))} agent(s) · scope ${paint(RAW.bold, scope === 'project' ? 'workspace' : scope)}`);
+  info(`${Verb}ing ${paint(RAW.bold, String(skills.length))} skill(s) ${action === 'remove' ? 'from' : 'into'} ${paint(RAW.bold, String(agentKeys.length))} agent(s) · scope ${paint(RAW.bold, scope === 'project' ? 'workspace' : scope)}`);
+
   let count = 0;
-  for (const sc of scopes) for (const k of agentKeys) { installToAgent(k, AGENTS[k], sc, skills); count += skills.length; }
+  for (const sc of scopes) for (const k of agentKeys) {
+    if (action === 'remove') count += removeFromAgent(k, AGENTS[k], sc, skills);
+    else { installToAgent(k, AGENTS[k], sc, skills); count += skills.length; }
+  }
 
   console.log('');
-  box([
-    `Installed ${paint(RAW.bold, String(skills.length))} skill(s) into ${paint(RAW.bold, String(agentKeys.length))} agent(s)`,
-    `scope: ${scopes.map((s) => (s === 'project' ? 'workspace' : s)).join(' + ')}   ·   ${count} item(s) written`,
-    `next: open your agent and say "write our F6S profile copy"`,
-  ]);
+  if (action === 'remove') {
+    box([
+      `Removed ${paint(RAW.bold, String(count))} item(s) from ${paint(RAW.bold, String(agentKeys.length))} agent(s)`,
+      `scope: ${scopes.map((s) => (s === 'project' ? 'workspace' : s)).join(' + ')}`,
+      count === 0 ? `nothing matched — already clean` : `done — skills removed`,
+    ]);
+  } else {
+    box([
+      `Installed ${paint(RAW.bold, String(skills.length))} skill(s) into ${paint(RAW.bold, String(agentKeys.length))} agent(s)`,
+      `scope: ${scopes.map((s) => (s === 'project' ? 'workspace' : s)).join(' + ')}   ·   ${count} item(s) written`,
+      `next: open your agent and say "write our F6S profile copy"`,
+    ]);
+  }
   console.log('');
 }
 

package/install.sh

@@ -62,7 +62,8 @@ usage() {
 spirewise — install copywriting Agent Skills into all your AI agents.
 
 Usage:
-  install.sh [scope] [-a agents] [-s skills]
+  install.sh [install] [scope] [-a agents] [-s skills]
+  install.sh remove   [scope] [-a agents] [-s skills]   # uninstall (alias: uninstall)
 
 Scope:
   -sc, --scope <s>   workspace | global | both
@@ -161,8 +162,22 @@ resolve_dir() {
 install_for_agent() {
   local key="$1" label="$2" fmt="$3" ext="$4" dir="$5" scope="$6" base="$7"; shift 7
   local skills=("$@")
-  mkdir -p "$dir"
   local s
+  if [[ "$MODE" == "remove" ]]; then
+    for s in "${skills[@]}"; do
+      local target
+      if [[ "$fmt" == "skill" ]]; then target="$dir/$s"; else target="$dir/$s$ext"; fi
+      if [[ -e "$target" ]]; then
+        rm -rf "$target"; REMOVED=$((REMOVED+1))
+        substep "$label ($scope) $s removed <- $target"
+      else
+        substep "$label ($scope) $s — not found, skipped"
+      fi
+    done
+    [[ -d "$dir" ]] && rmdir "$dir" 2>/dev/null || true
+    return 0
+  fi
+  mkdir -p "$dir"
   for s in "${skills[@]}"; do
     fetch_skill "$s" "$base"
     if [[ "$fmt" == "skill" ]]; then
@@ -180,12 +195,18 @@ install_for_agent() {
 }
 
 # ---- Parse args ------------------------------------------------------------
+MODE="install"
+REMOVED=0
 SCOPE=""
 AGENT_FILTER=""
 DO_LIST=false
 SELECTED=()
+[[ "${1:-}" == "remove" || "${1:-}" == "uninstall" ]] && { MODE="remove"; shift; }
+[[ "${1:-}" == "install" ]] && shift
 while [[ $# -gt 0 ]]; do
   case "$1" in
+    remove|uninstall) MODE="remove"; shift ;;
+    --remove|--uninstall) MODE="remove"; shift ;;
     --project|--workspace|--local) SCOPE="project"; shift ;;
     --global)  SCOPE="global"; shift ;;
     --both)    SCOPE="both"; shift ;;
@@ -228,10 +249,10 @@ step 2 "Selecting target agents"
 if [[ -n "$AGENT_FILTER" ]]; then substep "agents: $AGENT_FILTER"; else substep "agents: all supported"; fi
 
 # Step 3: scope — prompt if not given.
-step 3 "Choosing install scope"
+step 3 "Choosing scope"
 if [[ -z "$SCOPE" ]]; then
   if [[ -t 0 ]]; then
-    info "Where should the skills be installed?"
+    [[ "$MODE" == "remove" ]] && info "Where should the skills be removed from?" || info "Where should the skills be installed?"
     echo "  1) Workspace   (this folder only — current project)"
     echo "  2) Global      (your home folders — all projects)"
     echo "  3) Both"
@@ -247,8 +268,8 @@ fi
 
 SCOPES=("$SCOPE"); [[ "$SCOPE" == "both" ]] && SCOPES=("project" "global")
 
-# Step 4: install
-step 4 "Installing"
+# Step 4: install / remove
+[[ "$MODE" == "remove" ]] && step 4 "Removing" || step 4 "Installing"
 for sc in "${SCOPES[@]}"; do
   for entry in "${AGENTS[@]}"; do
     IFS='|' read -r key label fmt ext pdir gdir <<<"$entry"
@@ -256,10 +277,15 @@ for sc in "${SCOPES[@]}"; do
       case ",$AGENT_FILTER," in *",$key,"*) ;; *) continue ;; esac
     fi
     if [[ "$sc" == "project" ]]; then dir="$(resolve_dir "$pdir")"; else dir="$(resolve_dir "$gdir")"; fi
-    install_for_agent "$key" "$label" "$fmt" "$ext" "$dir" "$sc" "$BASE" "${SELECTED[@]}"
+    scope_tag="$sc"; [[ "$sc" == "project" ]] && scope_tag="workspace"
+    install_for_agent "$key" "$label" "$fmt" "$ext" "$dir" "$scope_tag" "$BASE" "${SELECTED[@]}"
   done
 done
 
 printf '\n'
-ok "Installed ${#SELECTED[@]} skill(s). Next: open your agent and say \"write our F6S profile copy\"."
+if [[ "$MODE" == "remove" ]]; then
+  ok "Removed $REMOVED item(s)."
+else
+  ok "Installed ${#SELECTED[@]} skill(s). Next: open your agent and say \"write our F6S profile copy\"."
+fi
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spirewise",
-  "version": "1.1.0",
+  "version": "1.6.0",
   "description": "Installable Agent Skills for copywriting (F6S & LinkedIn company pages) for GitHub Copilot, Claude Code, and Cursor.",
   "bin": {
     "spirewise": "bin/cli.js"

package/skills/README.md

@@ -9,6 +9,9 @@ ready-to-paste copy for company profile pages, with strict character-limit safet
 |-------|--------|---------|
 | `f6s-copywriting` | `f6s/f6s-profile-copy.txt` | Full F6S startup profile copy |
 | `linkedin-copywriting` | `linkedin copywriting/linkedin-page-copy.txt` | Full LinkedIn Company Page copy |
+| `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 |
 
 Each skill writes one plain-text file and keeps **every field below** the
 platform's character limit (with ~10% headroom).
@@ -54,6 +57,17 @@ Flags:
 In the picker: **↑/↓** move, **space** toggle, **a** all/none, **enter**
 confirm, **esc** cancel.
 
+### Uninstall
+
+`remove` (alias `uninstall`) reuses the same picker/flags and deletes skills from
+workspace, global, or both:
+
+```bash
+npx spirewise remove                 # interactive
+npx spirewise remove -sc both        # pick skills+agents, both scopes
+npx spirewise remove -s f6s-copywriting -a cursor -sc workspace
+```
+
 Supported agents and their folders (workspace / global):
 
 | Agent | Workspace | Global | Format |
@@ -78,6 +92,7 @@ If you can't use npm, the bundled `install.sh` mirrors the CLI over `curl`:
 ```bash
 # from a clone
 ./install.sh --both
+./install.sh remove --both        # uninstall
 
 # remote
 curl -fsSL https://raw.githubusercontent.com/spirerise/spirewise/main/install.sh | bash -s -- --both

package/skills/f6s-copywriting/README.md

@@ -0,0 +1,53 @@
+# f6s-copywriting
+
+Generate complete, ready-to-paste copy for an **F6S (f6s.com)** startup/company
+profile — written like a senior unicorn-startup marketer: humanized,
+attention-grabbing, and conversion-focused, with **every field kept under its
+character limit**.
+
+## Install
+
+```bash
+npx spirewise install -s f6s-copywriting          # pick agents + scope
+npx spirewise install -s f6s-copywriting -a claude,cursor -sc workspace
+```
+
+## Remove
+
+```bash
+npx spirewise remove -s f6s-copywriting           # pick agents + scope
+npx spirewise remove -s f6s-copywriting -a claude,cursor -sc both
+```
+
+(No Node? `./install.sh -s f6s-copywriting` and `./install.sh remove -s f6s-copywriting`.)
+
+## Use
+
+After installing, ask your agent:
+
+> "Write our F6S profile copy"
+
+It gathers your company details, then writes **`f6s/f6s-profile-copy.txt`** in
+your project root.
+
+## Output
+
+`f6s/f6s-profile-copy.txt` — every F6S field (name, tagline, short/full
+description, product, business model, traction, needs, team, etc.) with a live
+`(count/limit)` next to each length-limited field.
+
+## Character limits (kept under, ~10% headroom)
+
+| Field | Limit |
+|---|---|
+| Company name | 50 |
+| Tagline / one-liner | 140 |
+| Short description | 255 |
+| Full description | 2000 |
+| Product description | 1000 |
+| Business model | 500 |
+| Traction / achievements | 1000 |
+| Needs / seeking | 500 |
+| Team member bio (each) | 500 |
+
+See `SKILL.md` for the full voice/quality standard and output template.

package/skills/linkedin-copywriting/README.md

@@ -0,0 +1,49 @@
+# linkedin-copywriting
+
+Generate complete, ready-to-paste copy for a **LinkedIn Company Page** — written
+like a senior unicorn-startup marketer: humanized, attention-grabbing, and
+conversion-focused, with **every field kept under its character limit**.
+
+## Install
+
+```bash
+npx spirewise install -s linkedin-copywriting          # pick agents + scope
+npx spirewise install -s linkedin-copywriting -a claude,cursor -sc workspace
+```
+
+## Remove
+
+```bash
+npx spirewise remove -s linkedin-copywriting           # pick agents + scope
+npx spirewise remove -s linkedin-copywriting -a claude,cursor -sc both
+```
+
+(No Node? `./install.sh -s linkedin-copywriting` and `./install.sh remove -s linkedin-copywriting`.)
+
+## Use
+
+After installing, ask your agent:
+
+> "Create the LinkedIn company page copy"
+
+It gathers your company details, then writes
+**`linkedin copywriting/linkedin-page-copy.txt`** in your project root.
+
+## Output
+
+`linkedin copywriting/linkedin-page-copy.txt` — company name, tagline, About /
+Overview, specialties, industry, size, HQ, founded, and an optional intro post,
+each with a live `(count/limit)`.
+
+## Character limits (kept under, ~10% headroom)
+
+| Field | Limit |
+|---|---|
+| Company name | 100 |
+| Tagline | 120 |
+| About / Overview | 2000 (first ~150 chars = preview hook) |
+| Specialty (each) | 30 |
+| Specialties (total) | 20 items |
+| Intro/launch post | 3000 |
+
+See `SKILL.md` for the full voice/quality standard and output template.

package/skills/nvidia-inception-idea-booster/README.md

@@ -0,0 +1,55 @@
+# nvidia-inception-idea-booster
+
+Reads your **existing startup-idea files** in the project and elevates the idea
+into a stronger, defensible, **NVIDIA-Inception-ready** version — using exactly
+the traits NVIDIA prefers (deep tech, physical/agentic AI, essential GPU
+acceleration, defensibility, large markets, NVIDIA ecosystem fit). It elevates
+your real idea; it does not invent a different company.
+
+> Pairs with **`nvidia-inception-starter`**: boost the idea here, then score and
+> audit it there.
+
+## Install
+
+```bash
+npx spirewise install -s nvidia-inception-idea-booster          # pick agents + scope
+npx spirewise install -s nvidia-inception-idea-booster -a claude,cursor -sc workspace
+```
+
+## Remove
+
+```bash
+npx spirewise remove -s nvidia-inception-idea-booster           # pick agents + scope
+npx spirewise remove -s nvidia-inception-idea-booster -a claude,cursor -sc both
+```
+
+(No Node? `./install.sh -s nvidia-inception-idea-booster` and `./install.sh remove -s nvidia-inception-idea-booster`.)
+
+## Use
+
+Put your idea notes anywhere in the project (`idea.md`, `README`, `pitch`,
+`vision`, `notes`, a one-pager, etc.), then ask your agent:
+
+> "Make my startup idea stronger for NVIDIA Inception"
+
+It reads those files and writes **`nvidia-inception/elevated-idea.md`**.
+
+## Output
+
+`nvidia-inception/elevated-idea.md` — original idea (restated), an elevated
+one-liner and pitch, a **before → after** upgrade table across every
+NVIDIA-preference lever, a recommended NVIDIA stack (tech → use case → reason),
+a moat plan, a beachhead→expansion market path, a proof plan, and honest gaps.
+
+## NVIDIA-preference levers it optimizes
+
+| Lever | What it pushes for |
+|---|---|
+| Deep tech / IP | Real model/system/hardware differentiation, not an AI wrapper |
+| Physical / Agentic AI | Robotics, autonomy, embodied/edge, action-taking agents |
+| GPU essential | Workloads that genuinely require accelerated compute |
+| Defensibility | Proprietary data/model/hardware or NVIDIA-stack integration |
+| Market & why-now | Large TAM, clear beachhead, commercialization path |
+| Ecosystem fit | Authentic use of CUDA, Isaac, Omniverse, Jetson, NIM, etc. |
+
+See `SKILL.md` for the full method and output template.

package/skills/nvidia-inception-idea-booster/SKILL.md

@@ -0,0 +1,151 @@
+---
+name: nvidia-inception-idea-booster
+description: >-
+  Read a startup's existing idea/notes files in the project and elevate the idea
+  into a far stronger, NVIDIA-Inception-ready version — leaning on exactly the
+  traits NVIDIA prefers (deep tech, physical/agentic AI, essential GPU
+  acceleration, defensibility, large markets, NVIDIA ecosystem fit). Use when the
+  user asks to "make my startup idea stronger for NVIDIA", "elevate my idea",
+  "improve my startup for Inception", or "rewrite my idea to fit NVIDIA". Writes
+  an elevated idea document to an `nvidia-inception/` folder in the project root.
+  For scoring/auditing an existing company, use nvidia-inception-starter instead.
+---
+
+# NVIDIA Inception Idea Booster
+
+Take whatever startup idea already exists in the project, understand it deeply,
+then **transform it into a stronger, defensible, NVIDIA-aligned idea** that maps
+to what NVIDIA Inception actually rewards — without inventing a different company.
+
+## When to use vs. the sibling skill
+
+- **This skill** reshapes and strengthens the *idea* itself (positioning, wedge,
+  tech depth, NVIDIA fit), starting from the user's existing files.
+- **`nvidia-inception-starter`** scores and audits an existing company against
+  acceptance criteria and writes a readiness report.
+
+Use both together: boost the idea here, then score it there.
+
+## Step 1 — Read the existing idea
+
+Discover and read the startup-related files already in the project. Look for:
+- `idea*.md/.txt`, `README*`, `pitch*`, `business-plan*`, `vision*`, `notes*`,
+  `one-pager*`, `deck*`, `prd*`, `concept*`, `startup*`, and any `docs/` content.
+- Prefer Markdown/text/PDF-exported notes. Scan the repo for whatever describes
+  the problem, product, market, and tech.
+
+Extract and restate, in your own words:
+- Problem, who has it, and current alternatives
+- Proposed product/solution and how it works
+- Target market and business model
+- Any AI/ML, data, or compute involved
+- Team, stage, traction, and named tech stack
+
+If little exists, ask 3–5 focused questions before boosting. **Never discard the
+founder's core intent** — elevate it, don't replace it. Flag unknowns as
+`[UNKNOWN]` rather than inventing facts.
+
+## What NVIDIA prefers (the levers you optimize for)
+
+Pull the idea toward these — but only where it's authentic to the product:
+
+1. **Deep tech / novel IP** — real algorithmic, model, system, or hardware
+   differentiation; not an "AI wrapper" over someone else's API.
+2. **Physical & agentic AI** — robotics, autonomy, embodied/edge AI, perception
+   + navigation + actuation, or agents that take real actions. NVIDIA is leaning
+   hard into Physical AI.
+3. **GPU acceleration is essential** — the workload genuinely needs accelerated
+   compute (training/fine-tuning, large-scale inference, simulation, 3D, RL,
+   vision, LLMs) — GPUs are a *must-have*, not a nice-to-have.
+4. **Defensibility / moat** — proprietary models, a unique/proprietary dataset,
+   custom hardware, or deep integration with the NVIDIA stack for stickiness.
+5. **Large, impactful market** — autonomy, robotics, healthcare AI, advanced
+   manufacturing, smart cities, enterprise AI — clear, massive TAM and a path to
+   commercialize and scale globally.
+6. **Technical rigor & momentum** — prototypes, benchmarks, pilots, publications;
+   a credible, technical founding team.
+7. **NVIDIA ecosystem synergy** — would clearly use and benefit from NVIDIA
+   platforms (CUDA, TensorRT, Triton, NIM, NeMo, Riva, Metropolis, Holoscan,
+   Omniverse, Isaac, Jetson, DGX / NVIDIA AI Enterprise), and could collaborate
+   on reference designs / whitepapers / joint GTM.
+
+Excluded/weak profiles to steer away from: consulting/outsourcing, crypto
+mining/trading, pure reselling, thin AI wrappers with no real compute need.
+
+## Step 2 — Elevate the idea
+
+For each lever, produce a concrete upgrade to the existing idea:
+- **Sharpen the wedge:** a specific, painful, narrow beachhead use case where
+  the product wins decisively before expanding.
+- **Deepen the tech:** identify where to add genuine deep-tech depth (a
+  proprietary model, a data flywheel, a simulation/edge component) so GPUs become
+  essential. Be honest about what is real vs. aspirational.
+- **Add a Physical/Agentic angle where credible:** reframe toward embodied/edge
+  or agentic execution if it fits the problem — don't force it.
+- **Build the moat:** name the defensible asset (data, model, hardware,
+  integration) and how it compounds over time.
+- **Right-size the market:** beachhead → adjacent expansion → full TAM, with the
+  "why now."
+- **Map NVIDIA tech authentically:** for each technical need, the specific NVIDIA
+  technology that serves it and why — tied to a real use case, never as buzzwords.
+
+Always keep two views: the **original idea** and the **elevated idea**, so the
+founder sees exactly what changed and why it raises acceptance odds.
+
+## Output — write the elevated idea
+
+1. Create an `nvidia-inception/` folder in the project root if missing.
+2. Write `nvidia-inception/elevated-idea.md` (UTF-8 Markdown):
+
+```
+# Elevated Startup Idea — <Company / Working Name>
+Generated: <YYYY-MM-DD>
+Sources read: <list the files you ingested>
+
+## Original Idea (as understood)
+<faithful restatement of the founder's current idea>
+
+## Elevated One-Liner
+<one sharp sentence, NVIDIA-aligned, no hype>
+
+## Elevated Pitch (problem → wedge → solution → why now)
+
+## NVIDIA-Preference Upgrades
+| Lever | Before | After (elevated) | Why it helps acceptance |
+|---|---|---|---|
+| Deep tech / IP | … | … | … |
+| Physical / Agentic AI | … | … | … |
+| GPU essential | … | … | … |
+| Defensibility / moat | … | … | … |
+| Market & why-now | … | … | … |
+| NVIDIA ecosystem fit | … | … | … |
+
+## Recommended NVIDIA Stack (tech → use case → reason)
+
+## Defensibility / Moat Plan
+
+## Beachhead → Expansion Market Path
+
+## Proof Plan (prototype, benchmark, pilot, publication)
+
+## Risks & Honest Gaps        (incl. anything still [UNKNOWN])
+
+## Next Steps                  (so it's ready for nvidia-inception-starter scoring)
+```
+
+## Quality bar
+
+- **Elevate, don't fabricate.** Strengthen the real idea; never swap it for a
+  trendier one or claim capabilities that don't exist.
+- Make GPU dependence and the moat *believable*, with specifics.
+- Recommend NVIDIA tech only where it authentically fits a stated need.
+- Keep the before/after explicit so the founder can choose what to adopt.
+
+## Verification checklist (run before finishing)
+
+1. You actually read the existing idea files and listed them under "Sources read".
+2. `nvidia-inception/elevated-idea.md` exists with every section above.
+3. The elevated idea preserves the founder's core intent.
+4. Every NVIDIA-preference lever has a concrete before → after upgrade.
+5. NVIDIA tech recommendations are tied to real use cases, not buzzwords.
+6. Honest gaps and `[UNKNOWN]`s are stated, not hidden.

package/skills/nvidia-inception-starter/README.md

@@ -0,0 +1,61 @@
+# nvidia-inception-starter
+
+An expert advisor that prepares, evaluates, and optimizes your startup for
+**NVIDIA Inception** acceptance — it researches the program and accepted
+companies, scores you **0–100**, audits website/product/AI/architecture/NVIDIA
+alignment, and writes a full readiness report with a 90-day plan.
+
+## Install
+
+```bash
+npx spirewise install -s nvidia-inception-starter          # pick agents + scope
+npx spirewise install -s nvidia-inception-starter -a claude,cursor -sc workspace
+```
+
+## Remove
+
+```bash
+npx spirewise remove -s nvidia-inception-starter           # pick agents + scope
+npx spirewise remove -s nvidia-inception-starter -a claude,cursor -sc both
+```
+
+(No Node? `./install.sh -s nvidia-inception-starter` and `./install.sh remove -s nvidia-inception-starter`.)
+
+## Use
+
+After installing, ask your agent:
+
+> "Assess my startup for NVIDIA Inception"
+
+It collects your company details (and researches the program + accepted
+startups), then writes
+**`nvidia-inception/inception-readiness-report.md`** in your project root.
+
+## Output
+
+`nvidia-inception/inception-readiness-report.md` — Executive summary, Acceptance
+Score (0–100), Acceptance Probability, Strength/Weakness analysis, Competitive
+analysis, Website / Product / AI / Architecture / NVIDIA-alignment audits, an
+Improvement Roadmap, a 90-Day Action Plan, and an Application Readiness report.
+
+## Scoring weights
+
+| Category | Weight |
+|---|---|
+| AI Strength | 20 |
+| Technical Innovation | 15 |
+| NVIDIA Alignment | 15 |
+| Market Opportunity | 10 |
+| Team Quality | 10 |
+| Product Maturity | 10 |
+| Website Quality | 5 |
+| Pitch Readiness | 5 |
+| Scalability | 5 |
+| Competitive Advantage | 5 |
+
+## Good to know
+
+NVIDIA Inception is **free, equity-free**, has **no deadline**, and is open to
+**all funding stages**. Core eligibility: incorporated, working website,
+business email, ≥1 developer, generally <10 years old, building an **AI product**
+(not consulting). See `SKILL.md` for the full method, facts, and report template.

package/skills/nvidia-inception-starter/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: nvidia-inception-starter
+description: >-
+  Expert startup advisor that prepares, evaluates, and optimizes a startup for
+  acceptance into NVIDIA Inception. Use when the user asks to "assess my startup
+  for NVIDIA Inception", "am I ready for NVIDIA Inception", "improve my NVIDIA
+  application", "NVIDIA Inception readiness", or wants a scored audit + roadmap.
+  Researches NVIDIA Inception and accepted startups, scores the company 0–100,
+  audits website/product/AI/architecture/NVIDIA-alignment, and writes a full
+  readiness report to an `nvidia-inception/` folder in the project root.
+---
+
+# NVIDIA Inception Starter
+
+Prepare a startup for NVIDIA Inception: research the program and its accepted
+companies, score the startup, audit every dimension that affects acceptance, and
+produce a brutally honest readiness report with a 90-day action plan.
+
+## Persona
+
+Act as a **former NVIDIA Inception evaluator, AI startup investor, accelerator
+mentor, and deep-tech strategist**. Be evidence-based, data-driven, highly
+critical, and brutally accurate, but always actionable. Hold both an investor
+mindset and a technical mindset. Never inflate scores to be nice — a realistic,
+specific critique is more valuable than encouragement.
+
+## Inputs needed
+
+Gather (ask, or infer from the repo/website/links the user provides):
+- Company name, website, one-line description, incorporation status + age
+- What it builds, target market, industry, business model, pricing
+- AI/ML usage and category (CV, GenAI, robotics, physical AI, enterprise AI…)
+- Technical stack and any NVIDIA technologies used
+- Funding stage, traction (users, revenue, growth, partnerships), team/founders
+- Pitch deck / homepage copy if available
+
+If details are missing, mark them as `[UNKNOWN]` in the report and lower the
+relevant scores — do not invent facts.
+
+## Step 1 — Research (do this before scoring)
+
+Research to current, real sources. Do not rely on memory alone.
+- **Official program:** eligibility, application process, tiers, benefits, FAQ
+  (nvidia.com/startups and the Inception FAQ).
+- **Accepted startups:** study a broad sample (aim for many, ideally 50–100+)
+  from NVIDIA startup showcases, member spotlights, case studies, and blogs.
+- For each accepted startup, note: industry, problem, market, product/AI
+  category, funding stage, tech stack, NVIDIA tech used, homepage headline,
+  value prop, traction, and competitive edge.
+- **Detect patterns:** most common categories, AI use cases, funding stages,
+  founder backgrounds, website structures, messaging, and NVIDIA-tech usage.
+- Convert patterns into **acceptance signals** (what accepted startups share)
+  and **risk signals** (what rejected/ineligible profiles share).
+
+## Verified program facts (ground truth — keep current by re-checking)
+
+Eligibility (typical):
+- **Free, equity-free, no fees.** No application deadline; rolling review
+  (usually a few business days to ~2 weeks).
+- Must be **incorporated** (registered legal entity), have a **working company
+  website**, use a **business email** (no generic/alias addresses), and employ
+  **at least one developer**.
+- Generally **under 10 years old**, and **building AI / ML / data-science /
+  accelerated-computing products** — not selling consulting or outsourced dev.
+- **Open to all funding stages** (bootstrapped → growth).
+
+Commonly **not eligible**: consulting / outsourcing dev shops, crypto
+(mining/trading), pure cloud service providers, resellers/distributors, and
+public companies.
+
+Tiers (startups progress as they grow): **Emerging → Scale → Premier**. Higher
+tiers unlock more cloud credits, deeper engineering support, DLI training,
+co-marketing, and investor access.
+
+Benefits: NVIDIA SDKs + developer tools, Deep Learning Institute (DLI) training,
+preferred hardware pricing, partner **cloud credits**, **Inception Capital
+Connect / VC Alliance** investor access, co-marketing, badges, and events.
+
+NVIDIA technologies to align with (cite the ones that genuinely fit): CUDA,
+cuDNN, TensorRT, Triton, RAPIDS, NIM, NeMo, Riva, Metropolis, Holoscan,
+Omniverse, Isaac (robotics), Jetson (edge), DGX / NVIDIA AI Enterprise.
+
+## Step 2 — Score the startup (0–100)
+
+Score each category, multiply by weight, sum to a total. Always justify each
+score with specific evidence and a one-line "to reach the next level" note.
+
+| Category | Weight |
+|---|---|
+| AI Strength | 20 |
+| Technical Innovation | 15 |
+| NVIDIA Alignment | 15 |
+| Market Opportunity | 10 |
+| Team Quality | 10 |
+| Product Maturity | 10 |
+| Website Quality | 5 |
+| Pitch Readiness | 5 |
+| Scalability | 5 |
+| Competitive Advantage | 5 |
+
+Map the total to an **acceptance probability** band and state it plainly:
+- 85–100 — Very strong; likely accept. Polish and apply now.
+- 70–84 — Strong; address 2–3 gaps, then apply.
+- 50–69 — Borderline; meaningful work needed before applying.
+- < 50 — Not ready; follow the roadmap first.
+
+NVIDIA Alignment scoring guide: highest when the startup genuinely trains/runs
+GPU-accelerated AI and would use NVIDIA tech in production; low for thin
+"AI wrapper" products with no real compute need. Reward authenticity, not
+buzzwords.
+
+## Step 3 — Audits
+
+Run each and list concrete findings + fixes:
+- **Website audit:** homepage headline, value proposition, product + AI
+  explanation, technical credibility, use cases, case studies, architecture
+  clarity, visual quality, trust signals, investor readiness. Compare against
+  top Inception / fast-growing AI startups.
+- **Product audit:** maturity (idea → MVP → production), differentiation, moat.
+- **AI readiness audit:** real AI vs. wrapper, data advantage, model strategy,
+  evaluation/quality, compute needs.
+- **Technical architecture audit:** scalability, GPU utilization, inference
+  path, edge vs. cloud, MLOps.
+- **NVIDIA alignment audit:** which NVIDIA technologies fit and how to adopt
+  them credibly in the roadmap.
+
+## Physical / Embodied AI module (if relevant)
+
+If the startup touches robotics, autonomous/industrial systems, vision AI, edge
+AI, digital twins, simulation, agentic, or embodied AI, recommend the fitting
+stack: **Isaac** (robotics), **Omniverse** (simulation/digital twins),
+**Jetson** (edge), **CUDA/TensorRT** (perf), **NIM** (inference microservices),
+**NVIDIA AI Enterprise**. Tie each recommendation to a concrete use case — never
+list tech for its own sake.
+
+## Output — write the report file
+
+1. Create an `nvidia-inception/` folder in the project root if missing.
+2. Write `nvidia-inception/inception-readiness-report.md` (UTF-8 Markdown) with:
+
+```
+# NVIDIA Inception Readiness — <Company>
+Generated: <YYYY-MM-DD>
+
+## Executive Summary
+## NVIDIA Inception Acceptance Score   (XX/100, with per-category table)
+## Acceptance Probability               (band + one-line verdict)
+## Strength Analysis
+## Weakness Analysis
+## Competitive Analysis
+## Website Audit
+## Product Audit
+## AI Readiness Audit
+## Technical Architecture Audit
+## NVIDIA Alignment Audit
+## Improvement Roadmap                   (prioritized, effort vs. impact)
+## 90-Day Action Plan                    (Days 0–30 / 31–60 / 61–90, owners)
+## Application Readiness Report           (eligibility checklist + go/no-go)
+```
+
+Include the eligibility checklist explicitly (incorporated, website, business
+email, ≥1 developer, <10 yrs, AI product not consulting, not in an excluded
+category) and flag any blocker that would cause an automatic rejection.
+
+## Quality bar
+
+- Evidence over opinion: cite the accepted-startup patterns your scores rely on.
+- Be specific and quantified; replace vague advice with concrete next actions.
+- Brutally honest: if it's not ready, say so and explain exactly why.
+- Recommend NVIDIA tech only where it authentically fits the product.
+
+## Verification checklist (run before finishing)
+
+1. `nvidia-inception/inception-readiness-report.md` exists with every section.
+2. Category scores sum correctly to the 0–100 total; each has evidence.
+3. Acceptance probability band matches the total score.
+4. Eligibility checklist is complete; any auto-reject blocker is flagged.
+5. Every recommendation is specific, prioritized, and actionable.
+6. No invented facts — unknowns are marked `[UNKNOWN]`, not fabricated.

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

@@ -0,0 +1,66 @@
+# nvidia-product-inventor
+
+Reads your **existing startup-idea files** and invents **3–6 concrete products**
+(not marketing copy) engineered to fit NVIDIA Inception. 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.
+
+> Builds on **`nvidia-inception-idea-booster`** (preference levers) and
+> **`nvidia-inception-starter`** (acceptance lens). Products only — no website
+> or landing-page copy.
+
+## Install
+
+```bash
+npx spirewise install -s nvidia-product-inventor          # pick agents + scope
+npx spirewise install -s nvidia-product-inventor -a claude,cursor -sc workspace
+```
+
+## Remove
+
+```bash
+npx spirewise remove -s nvidia-product-inventor           # pick agents + scope
+npx spirewise remove -s nvidia-product-inventor -a claude,cursor -sc both
+```
+
+(No Node? `./install.sh -s nvidia-product-inventor` and `./install.sh remove -s nvidia-product-inventor`.)
+
+## Use
+
+Put your idea notes anywhere in the project, then ask your agent:
+
+> "Invent products for NVIDIA Inception from our idea"
+
+It reads those files and writes a **`products_raw/`** folder with one subfolder
+per product.
+
+## Output
+
+```
+products_raw/
+├── _overview.md            # all products: name, letters, one-liner, primary GPU
+├── <Product1>/
+│   ├── product.md
+│   ├── logo-brief.md
+│   └── <Product1>-logo-1080x1080.png
+├── <Product2>/…
+└── …                       # 3–6 products total
+```
+
+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.
+
+## Rules it enforces
+
+- **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.
+
+See `SKILL.md` for the full method and the per-product template.

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

@@ -0,0 +1,167 @@
+---
+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.
+---
+
+# NVIDIA Product Inventor
+
+Turn the startup's idea into **3–6 buildable products** that maximize NVIDIA
+Inception fit. This is a product/ideation skill — invent *what to build*, not
+marketing copy.
+
+## Uses the sibling skills
+
+- Apply the **NVIDIA-preference levers** from `nvidia-inception-idea-booster`
+  (deep tech, physical/agentic AI, GPU-essential, defensibility, big market,
+  ecosystem fit) when shaping every product.
+- Pre-screen each product with the **`nvidia-inception-starter`** acceptance lens
+  (AI strength, technical innovation, NVIDIA alignment, market, moat). Keep only
+  products that would plausibly score well; discard weak/"AI-wrapper" ones.
+
+## Step 1 — Read the existing idea
+
+Discover and read the startup files in the project: `idea*`, `README*`, `pitch*`,
+`business-plan*`, `vision*`, `notes*`, `one-pager*`, `concept*`, `startup*`,
+`docs/`, etc. Restate the problem, users, market, and any tech in your own words.
+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
+
+Generate **between 3 and 6** product concepts that each:
+- Solve a sharp, real problem within the startup's domain.
+- **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).
+
+### Product naming rules (enforce strictly)
+- **4–10 letters**, letters only (A–Z), no spaces, digits, or symbols.
+- Brandable and coined/short (e.g., `Vexel`, `Roboq`, `Synapt`, `Orbix`).
+- Count the letters and confirm each name is within 4–10 before using it.
+- The product folder name = the product name.
+
+## NVIDIA stack for each product (order: physical → SDK → software)
+
+List concrete, fitting choices — **lead with physical/compute hardware (GPUs)**:
+
+1. **Physical / compute hardware (GPUs first):** data-center GPUs (H100, H200,
+   A100, GB200/Blackwell), workstation GPUs (RTX), **Jetson** (Orin/Nano) for
+   edge/robotics, **DGX** systems, **Grace Hopper / Grace Blackwell**, IGX/Holoscan
+   dev kits, robotics platforms on Jetson.
+2. **SDKs / libraries:** CUDA, cuDNN, **TensorRT**, **Triton** Inference Server,
+   RAPIDS, **Isaac** (Sim / ROS / Lab) for robotics, **Omniverse** for
+   simulation/digital twins, **Metropolis** for vision, **Holoscan** for sensor/edge,
+   **NeMo** for LLMs, **Riva** for speech, DeepStream, cuOpt, Modulus, Parabricks
+   (genomics), Morpheus (cybersecurity), Maxine.
+3. **Software / platforms:** **NVIDIA AI Enterprise**, **NIM** inference
+   microservices, NeMo framework/microservices, Omniverse Cloud, Fleet Command,
+   Base Command.
+
+Pick only what authentically fits each product, and say *why* each piece is used.
+
+## Output — `products_raw/` with one folder per product
+
+1. Create `products_raw/` in the project root if missing.
+2. For each product, create `products_raw/<ProductName>/` and write
+   `products_raw/<ProductName>/product.md`:
+
+```
+# <ProductName>
+Letters: <n> (must be 4–10)
+Tagline: <one line, what it is>
+Generated: <YYYY-MM-DD>
+
+## Problem
+## Target user
+## What it does (product, not marketing)
+## Why GPU / accelerated compute is essential
+
+## NVIDIA Stack
+### Physical / compute hardware (GPUs first)
+- <GPU / Jetson / DGX / …> — <why>
+### SDKs / libraries
+- <CUDA / TensorRT / Isaac / Omniverse / …> — <why>
+### Software / platforms
+- <NVIDIA AI Enterprise / NIM / …> — <why>
+
+## Physical AI / Edge angle        (if applicable)
+## Defensibility / moat
+## Market & wedge
+## Inception fit                    (1–2 lines: why this scores well)
+## Build notes / MVP scope
+## Logo                             (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.
+
+## 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.
+
+### 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.
+
+### 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.
+- 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.
+
+### 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.
+
+## Quality bar
+
+- **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.
+- 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.