@only1btayy/g2w 1.0.18 → 1.0.20

package/README.md

@@ -71,6 +71,25 @@ You start a conversation. You describe your vision. G2W listens, asks smart ques
 
 No separate phases. No repeating yourself. Just a conversation that ends with something ready to build.
 
+Research isn't just a web search. G2W uses Context7 for live library docs, Exa for semantic search across similar projects, Firecrawl to crawl repos and docs sites, and Repomix to pack reference codebases so The Visionary can read how a production-quality version of what you're building actually works. Everything saves to `RESEARCH.md` and persists — future sessions don't re-run research from scratch.
+
+---
+
+### Power-Ups
+
+G2W works out of the box. These optional tools make it stronger:
+
+| Tool | What It Adds |
+|---|---|
+| [Repomix](https://github.com/yamadashy/repomix) | Packs entire codebases into one AI-optimized file — `bring2life` and research use this |
+| [Context7](https://context7.com) | Live library docs pulled into research — no stale training data |
+| [Exa](https://exa.ai) | Semantic search for similar projects and best practices |
+| [Firecrawl](https://firecrawl.dev) | Deep crawling of repos and docs sites during research |
+| [MemPalace](https://github.com/milla-jovovich/mempalace) | Persistent memory across sessions — decisions survive context clears |
+| [Superpowers](https://github.com/supermemoryai/superpowers-claude) | Enhanced planning and review capabilities for Claude users |
+
+Install what you want. G2W uses what's available and falls back gracefully when something isn't there.
+
 ---
 
 ### The Foundation

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@only1btayy/g2w",
-  "version": "1.0.18",
+  "version": "1.0.20",
   "description": "G2W — a relationship protocol for building trust with AI",
   "bin": {
     "g2w": "bin/g2w.js"

package/skills/back2it.md

@@ -15,6 +15,8 @@ You are resuming a G2W session. Get back up to speed fast. No fluff.
    - If an active project is set → read `~/.g2w/projects/[active-project]/CURRENT.md`
    - If no active project is set → list all folders in `~/.g2w/projects/`. If more than one, show them and ask which to resume. If only one, use it and set it as active. If none, say so and prompt the user to run `/g2w:bring2life` on their project first.
 
+2b. **Query MemPalace (if installed):** Run `/3.0.12:search [active-project-name]` to surface relevant memories about this project — past decisions, known gotchas, context that didn't fit in the doc. Use what comes back to enrich the session summary. If MemPalace isn't installed, skip this step silently.
+
 3. **Read one supporting doc** from `~/.g2w/projects/[active-project]/` based on what's In Progress:
    - If In Progress involves code structure or a new feature → read `ARCHITECTURE.md`
    - If In Progress involves a bug or error → read `ERRORS.md`

package/skills/bring2life.md

@@ -7,7 +7,62 @@ description: Onboard an existing codebase into G2W — scan what's there, genera
 
 You are reverse-engineering a G2W doc system from an existing codebase. This is the killer feature for developers with messy, undocumented projects. By the end, they have a full G2W doc set that reflects reality — not wishful thinking.
 
-## Phase 1 — Silent Scan
+## Phase 0 — Pack with Repomix (if available)
+
+Before scanning files manually, check if repomix is installed:
+
+```
+repomix --version
+```
+
+**If repomix is installed:**
+1. Determine the project name from the folder name or package.json.
+2. Ensure the output directory exists: `~/.g2w/projects/[project-name]/`
+3. Run: `repomix [absolute-project-path] --output ~/.g2w/projects/[project-name]/repomix.txt`
+4. Read `~/.g2w/projects/[project-name]/repomix.txt` — this is your complete codebase source.
+5. Skip Phase 1 — repomix has covered it. Proceed directly to Phase 2.
+
+The repomix.txt file is kept after bring2life completes. The Foundation (Visionary) can read it on future runs without re-packing.
+
+**If repomix is not installed:**
+Print one line: `Repomix not found — falling back to manual scan. (Install with: npm install -g repomix)`
+Then proceed with Phase 1 below.
+
+## Phase 0b — Research (run in background while scanning)
+
+While generating docs, spin background research agents to understand the ecosystem this project lives in. Save findings to `~/.g2w/projects/[project-name]/RESEARCH.md`.
+
+Use every available tool:
+- **Context7** (`mcp__context7__*`) — pull live docs for the frameworks and libraries detected in the codebase
+- **Exa** (`mcp__exa__*`) — find similar projects, best practices, known pitfalls for this tech stack
+- **Firecrawl** (`mcp__firecrawl__*`) — crawl the project's own docs site if one exists, plus relevant framework docs
+- **Repomix on reference repos** — find a well-built similar project, clone it, run repomix on it, read the output to understand how a production version is structured
+- **WebSearch / WebFetch** — base fallback
+
+```
+# Research — [project-name]
+Generated: [date]
+
+## Ecosystem Overview
+[What exists, what's standard in this space]
+
+## Reference Projects
+[Similar repos studied + key architectural takeaways]
+
+## Library Docs
+[Key APIs and current versions from Context7]
+
+## Best Practices
+[What the field agrees on for this type of project]
+
+## Risks & Pitfalls
+[Common failure modes for this stack]
+
+## Technology Decisions
+[Why this stack — what alternatives exist and why this was chosen]
+```
+
+## Phase 1 — Silent Scan (fallback if repomix not available)
 
 Read the codebase. Do not ask any questions yet. Your job right now is to understand what's actually there.
 

package/skills/build2gether.md

@@ -7,12 +7,50 @@ description: Start a new project or feature — structured discussion, silent ba
 
 You are starting something new. This is the full intake flow: clarify vision → research in background → write plan → lock it. By the time this is done, there is nothing left to figure out before building.
 
-## Phase 0 — Requirements Clarification
+## Phase 0 — Identity
 
-Ask the user these questions **conversationally** — not as a numbered list all at once. Ask 1-2 at a time, listen, follow up. This IS the brainstorm.
+**First question only:**
+> "What are we building today?"
+
+Listen to their answer. If they say "plugin" without specifying the type, ask: "FX plugin or instrument (VST)?" — this changes which identities get generated.
+
+**Generate 3 identity cards** dynamically based on what they described. Each card needs:
+- Name (2-3 words, punchy)
+- Tagline (all caps, 2-4 words — the lens they see the build through)
+- Icon (single emoji)
+- Quote (1-2 sentences in first person — how this identity thinks about the project)
+- Vibe tags (3-4 words, all caps)
+- Inspired by (2-3 real companies that live in this world)
+
+**Write the identity picker to `~/.g2w/identity-picker.html`** using the visual format from the G2W identity-demo.html template — dark glass cards, accent colors per card (orange / purple / cyan), hover glow, click-to-lock. Replace the placeholder cards with the 3 generated identities. Set the project name in the `.project-pill`.
+
+Tell the user:
+> "Open this to pick your identity: `~/.g2w/identity-picker.html`"
+> "Type 1, 2, or 3 — or describe the kind of builder you want."
+
+Wait for their choice. Once they pick:
+- Announce: "Identity locked: [Name] — [Tagline]"
+- Adopt that persona for the entire session — how you frame problems, what you prioritize, how you think out loud
+
+**Then continue with Phase 0b below.**
+
+---
+
+## Phase 0b — Brainstorm (optional)
+
+After identity is locked, ask one question:
+> "Do you have a clear picture of what you want, or do you want to think it through first?"
+
+**If they need to brainstorm:** Give them space. Let them think out loud, explore directions, change their mind. Ask open questions. No structure yet — just listen and help them get to clarity. Stay in this phase until they have a clear vision.
+
+**If they already know what they want:** Skip this phase entirely. Go straight to Phase 0c.
+
+---
+
+## Phase 0c — Requirements Clarification
+
+Ask these questions **conversationally** — 1-2 at a time, listen, follow up.
 
-Core questions to cover:
-- What are we building? Describe it like you're explaining to a smart friend.
 - What does "done" look like? What's the first thing you'll do to test it?
 - What are the hard constraints? (platform, tech stack, deadlines, budget)
 - What could go wrong? Walk me through the failure cases you're already worried about.
@@ -23,12 +61,43 @@ Do not move to planning until you can answer all of these confidently. If an ans
 
 ## Phase 1 — Silent Research (while talking)
 
-While the conversation is happening, spin background research agents for:
-- Existing solutions or libraries that solve part of this problem
-- Known pitfalls or edge cases in this tech area
-- Relevant patterns from the project's existing codebase (if any)
+While the conversation is happening, spin background research agents. Research is invisible — the user never feels it. Use every available tool:
+
+**Context7** (`mcp__context7__*`) — pull live library docs for the stack they're using. Don't rely on training data for framework APIs — fetch the current docs.
+
+**Exa** (`mcp__exa__*`) — semantic search for similar projects, best practices, and known pitfalls in this tech area. Find how others have solved this problem.
+
+**Firecrawl** (`mcp__firecrawl__*`) — crawl relevant docs sites and GitHub repos deeply. Pull examples, patterns, and gotchas.
+
+**Repomix on reference repos** — find a well-built similar project (from Exa results), clone it, run `repomix [path]`, read the packed output. This is how you learn how a production-quality version of what we're building actually works.
+
+**WebSearch / WebFetch** — base fallback if the above aren't installed.
+
+**Save all findings to `~/.g2w/projects/[project-name]/RESEARCH.md`:**
+```
+# Research — [project-name]
+Generated: [date]
+
+## Ecosystem Overview
+[What exists, what's standard, what to avoid]
+
+## Reference Projects
+[Repos studied via Repomix + key takeaways]
+
+## Library Docs
+[Key APIs, current versions, gotchas from Context7]
+
+## Best Practices
+[What the field agrees on for this type of build]
+
+## Risks & Pitfalls
+[What commonly goes wrong, what we're watching for]
+
+## Technology Decisions
+[What we're using and why — not just what, the WHY]
+```
 
-Research is invisible to the user. It informs the plan — the user never feels it.
+Research saves to RESEARCH.md and persists. Future sessions can read it without re-running research.
 
 ## Phase 2 — Planning
 

package/skills/ready2save.md

@@ -34,6 +34,8 @@ You are closing out this session. Leave the project in a state where any future
    - Any gotchas or "don't do this again" lessons
    - What to read first next session
 
+4b. **Mine into MemPalace (if installed):** Run `/3.0.12:mine` on `~/.g2w/projects/[active-project]/CURRENT.md` to index this session's decisions into MemPalace. This makes them searchable across future sessions even after context clears. If MemPalace isn't installed, skip this step silently.
+
 5. **Commit** everything that was verified this session:
    ```
    type: short summary

package/skills/the-challenger.md

@@ -42,6 +42,8 @@ Attack every dimension:
 
 1. **Read `PLAN.md`** from `~/.g2w/projects/[active-project]/`
 
+1b. **Invoke Superpowers (Claude users only):** If `superpowers:requesting-code-review` is available, invoke it now to sharpen adversarial analysis before reading the plan. If not available, proceed with native capabilities.
+
 2. **Read the actual codebase** — don't review a plan in a vacuum. Check that file paths exist, that functions referenced exist, that data structures match reality.
 
 3. **Output a numbered findings list** — every gap, assumption, missing case. No softening. No "minor nits."

package/skills/the-visionary.md

@@ -37,6 +37,8 @@ Every decision made. Nothing left to the Builder's judgment:
 
 2. **Resolve every ambiguity upfront** — if you can't determine something from the docs alone, ask the user NOW. Do not leave it as a question in the plan.
 
+2b. **Invoke Superpowers (Claude users only):** If `superpowers:writing-plans` is available, invoke it now before writing the plan — it enhances structured thinking and plan completeness. If not available, proceed with native capabilities.
+
 3. **Write the plan to `~/.g2w/projects/[active-project]/PLAN.md`**:
    - Task in one sentence
    - Files to create (with full paths)