everything-gemini 1.0.1 → 1.1.1

package/.github/workflows/release.yml

@@ -40,3 +40,10 @@ jobs:
             LICENSE
             README.md
             CHANGELOG.md
+
+      - name: Publish to NPM
+        if: env.NPM_TOKEN != ''
+        run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+          NPM_TOKEN: ${{ secrets.NPM_TOKEN }}

package/CHANGELOG.md

@@ -4,6 +4,42 @@ All notable changes to **Everything Gemini (`everything-gemini`)** will be docum
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.1.1] - 2026-10-15
+
+### Added
+- **Social Media Preview Engine**: Rich Open Graph (`og:*`) and Twitter Card (`twitter:*`) metadata embedded in `docs/index.html` for rich link unfurling on social platforms.
+- **Turnkey Launch & Marketing Kit**: Added [`docs/LAUNCH_KIT.md`](docs/LAUNCH_KIT.md) featuring viral launch tweets, a 4-part thread, Reddit discussions, and Hacker News (Show HN) copy.
+- **Enhanced CLI Catalog Discovery**: `everything-gemini list` now dynamically scans and highlights namespaced skills packaged within domain plugins.
+- **Automated NPM Release CI**: Integrated automated npm publishing within `.github/workflows/release.yml` with provenance.
+
+---
+
+## [1.1.0] - 2026-10-15
+
+### Added
+- **27 Progressive Disclosure Skills Milestone**:
+  - **`github-ops`**: End-to-end GitHub automation, PR generation, code review triage, and semantic releases via `gh` CLI and GitHub MCP.
+  - **`ai-first-engineering`**: Requirement decomposition, executable acceptance criteria, and blast-radius containment.
+  - **`rag-architect`**: RAG engineering with `text-embedding-004`, hybrid search (dense + BM25), and Gemini re-ranking.
+  - **`gemini-function-calling`**: Production tool schemas, Pydantic output formatting, parallel execution, and error recovery envelopes.
+- **Interactive Web Catalog Expansion**: Updated [https://salmandev.github.io/everything-gemini/](https://salmandev.github.io/everything-gemini/) to feature all 27 progressive skills with instant search and category filtering.
+- **Enhanced CLI Commands**: Added `everything-gemini init` for quickstart setup, `everything-gemini remove <type> <name>` for component uninstallation, and `everything-gemini test-skill <name>` for validation.
+
+---
+
+## [1.0.2] - 2026-10-15
+
+### Added
+- **Interactive Web Showcase**: Launched official documentation and interactive skill catalog at [https://salmandev.github.io/everything-gemini/](https://salmandev.github.io/everything-gemini/).
+- **Component Granular Management**: Added `everything-gemini add <type> <name>` to install individual skills, agents, or plugins into any workspace on demand.
+- **Skill Quality Gate**: Added `everything-gemini test-skill <name>` validating frontmatter boundary syntax, descriptions, and script execution bits.
+- **Python SDK Multi-Agent Orchestration**: Complete runnable pipeline example in `examples/python-sdk/` showcasing programmatic leasing of Planner and Reviewer subagents with token streaming.
+- **Frontier Cloud & AI Skills**: Integrated `cloudflare-workers`, `supabase-architect`, `stripe-integration`, and `kubernetes-operator`.
+
+### Changed
+- CLI dynamically resolves package version from `package.json`.
+- Updated comprehensive CLI documentation across README and repository references.
+
 ---
 
 ## [1.0.1] - 2026-10-15

package/README.md

@@ -2,15 +2,19 @@
 
 <div align="center">
 
+<img src="assets/banner.jpg" alt="Everything Gemini Banner" width="100%" style="border-radius: 12px; margin-bottom: 16px;" />
+
+[![Live Showcase](https://img.shields.io/badge/Live_Showcase-Visit_Catalog-00e5ff.svg)](https://salmandev.github.io/everything-gemini/)
+[![npm version](https://img.shields.io/npm/v/everything-gemini.svg?color=cb3837)](https://www.npmjs.com/package/everything-gemini)
+[![CI](https://github.com/salmandev/everything-gemini/actions/workflows/ci.yml/badge.svg)](https://github.com/salmandev/everything-gemini/actions/workflows/ci.yml)
 [![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](LICENSE)
 [![Antigravity](https://img.shields.io/badge/Google-Antigravity-4285F4.svg)](https://antigravity.google)
-[![Version](https://img.shields.io/badge/version-1.0.1-emerald.svg)](package.json)
 [![Status](https://img.shields.io/badge/status-active-success.svg)](https://github.com/salmandev/everything-gemini)
 [![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg)](CONTRIBUTING.md)
 
 **The open-source agent harness, multi-agent orchestrator, and performance ecosystem for Google Gemini & Antigravity.**
 
-[Quickstart](#-quickstart) • [What is everything-gemini?](#-what-is-everything-gemini) • [Architecture](#-architecture--internals) • [Customization Catalog](#-customization-catalog) • [Surfaces Guide](#-the-4-antigravity-surfaces) • [Contributing](CONTRIBUTING.md)
+[Live Interactive Showcase](https://salmandev.github.io/everything-gemini/) • [Quickstart](#-quickstart) • [What is everything-gemini?](#-what-is-everything-gemini) • [Architecture](#-architecture--internals) • [Customization Catalog](#-customization-catalog) • [Surfaces Guide](#-the-4-antigravity-surfaces) • [Contributing](CONTRIBUTING.md)
 
 </div>
 
@@ -141,7 +145,7 @@ everything-gemini/
 ├── agents/                       # Scoped subagent fleet (Planner, Reviewer, Architect, etc.)
 ├── scripts/                      # Automated installers and harness validators
 ├── plugins/                      # Reusable modular plugins (web-fullstack, python-ai, security)
-├── skills/                       # 21+ Progressive disclosure skills
+├── skills/                       # 27 Progressive disclosure skills (25 core + 2 plugins)
 ├── rules/                        # Contextual guidelines & standards
 ├── hooks/                        # Event-driven lifecycle hooks (GeminiShield, Auto-lint)
 ├── mcp/                          # Production-ready MCP server blueprints
@@ -171,9 +175,19 @@ Skills in Antigravity are lazy-loaded runbooks. Only their YAML frontmatter (`na
 
 - **[`gemini-multimodal`](skills/gemini-multimodal/SKILL.md)**: Native visual reasoning over mockups, diagrams, and automated WebP browser recordings.
 - **[`context-caching`](skills/context-caching/SKILL.md)**: 1M-2M token context optimization, static prefix caching, and repository indexing.
+- **[`gemini-grounding`](skills/gemini-grounding/SKILL.md)**: Real-time Google Search grounding, live documentation retrieval, and fact-checking.
+- **[`rag-architect`](skills/rag-architect/SKILL.md)**: RAG pipeline design, AST semantic chunking, hybrid vector-keyword retrieval, and Gemini re-ranking.
+- **[`gemini-function-calling`](skills/gemini-function-calling/SKILL.md)**: Production function declarations, structured JSON output schemas (Pydantic), and parallel tool dispatch.
+- **[`ai-first-engineering`](skills/ai-first-engineering/SKILL.md)**: Requirement decomposition, executable acceptance criteria (BDD), and blast-radius containment.
+- **[`github-ops`](skills/github-ops/SKILL.md)**: GitHub workflow automation, PR generation, code review triage, and semantic releases with `gh` CLI & GitHub MCP.
 - **[`subagent-handoff`](skills/subagent-handoff/SKILL.md)**: Multi-agent task delegation protocol, scoped contexts, and report synthesis.
 - **[`api-craftsman`](skills/api-craftsman/SKILL.md)**: REST, OpenAPI 3.1 specifications, gRPC protos, and RFC 7807 error envelopes.
 - **[`database-architect`](skills/database-architect/SKILL.md)**: Zero-downtime migrations, concurrent indexing, and ACID schema modeling.
+- **[`fullstack-nextjs`](skills/fullstack-nextjs/SKILL.md)**: Next.js App Router, React Server Components (RSC), hydration error diagnosis, and Server Actions.
+- **[`supabase-architect`](skills/supabase-architect/SKILL.md)**: Row Level Security (RLS) policies, pgvector embeddings, and edge function workflows.
+- **[`cloudflare-workers`](skills/cloudflare-workers/SKILL.md)**: Serverless edge functions, Wrangler v3, D1 SQL, and KV low-latency storage.
+- **[`kubernetes-operator`](skills/kubernetes-operator/SKILL.md)**: Production k8s manifests, HPA autoscaling, zero-downtime rolling updates, and health probes.
+- **[`stripe-integration`](skills/stripe-integration/SKILL.md)**: Webhook signature verification, idempotent payments, and customer portal session flows.
 - **[`devops-pipeline`](skills/devops-pipeline/SKILL.md)**: Multi-stage Dockerfiles and caching GitHub Actions CI/CD workflows.
 - **[`root-cause-debugger`](skills/root-cause-debugger/SKILL.md)**: Regression diagnosis using binary search (`git bisect`) and minimal reproduction harnesses.
 - **[`tdd-workflow`](skills/tdd-workflow/SKILL.md)**: Red-Green-Refactor loop with automated test runners.
@@ -183,11 +197,6 @@ Skills in Antigravity are lazy-loaded runbooks. Only their YAML frontmatter (`na
 - **[`git-craftsman`](skills/git-craftsman/SKILL.md)**: Enforces conventional commits, atomic diffs, and clean PR descriptions.
 - **[`security-audit`](skills/security-audit/SKILL.md)**: Scans for credentials in commit history and audits dependency risks.
 - **[`performance-profiler`](skills/performance-profiler/SKILL.md)**: Identifies CPU/memory bottlenecks, analyzes database queries, and critical paths.
-- **[`gemini-grounding`](skills/gemini-grounding/SKILL.md)**: Real-time Google Search grounding, live documentation retrieval, and fact-checking.
-- **[`supabase-architect`](skills/supabase-architect/SKILL.md)**: Row Level Security (RLS) policies, pgvector embeddings, and edge function workflows.
-- **[`cloudflare-workers`](skills/cloudflare-workers/SKILL.md)**: Serverless edge functions, Wrangler v3, D1 SQL, and KV low-latency storage.
-- **[`kubernetes-operator`](skills/kubernetes-operator/SKILL.md)**: Production k8s manifests, HPA autoscaling, zero-downtime rolling updates, and health probes.
-- **[`stripe-integration`](skills/stripe-integration/SKILL.md)**: Webhook signature verification, idempotent payments, and customer portal session flows.
 - **[`continuous-learning`](skills/continuous-learning/SKILL.md)**: Codifies corrections and developer feedback into enduring Knowledge Items.
 
 ### 2. Lifecycle Hooks (`hooks/`)
@@ -281,13 +290,28 @@ The zero-dependency `everything-gemini` CLI manages your configurations effortle
 # List all available skills, rules, hooks, and plugins
 ./bin/everything-gemini list
 
+# Initialize everything-gemini in current workspace
+./bin/everything-gemini init
+
 # Add a specific skill to your active workspace
 ./bin/everything-gemini add skill tdd-workflow
 
+# Remove a skill from your active workspace
+./bin/everything-gemini remove skill tdd-workflow
+
 # Add a specific plugin
 ./bin/everything-gemini add plugin web-fullstack
 
-# Validate all schemas and frontmatter
+# Test and validate a specific skill's frontmatter and scripts
+./bin/everything-gemini test-skill gemini-multimodal
+
+# Scaffold a new progressive-disclosure skill
+./bin/everything-gemini new-skill my-custom-skill
+
+# Scaffold a new scoped subagent
+./bin/everything-gemini new-agent my-worker-agent
+
+# Validate all schemas, hooks, and frontmatter
 ./bin/everything-gemini validate
 ```
 

package/bin/everything-gemini

@@ -15,6 +15,11 @@ const GLOBAL_CONFIG_DIR = path.join(os.homedir(), '.gemini', 'config');
 const WORKSPACE_DIR = process.cwd();
 const AGENTS_DIR = path.join(WORKSPACE_DIR, '.agents');
 
+let VERSION = '1.0.1';
+try {
+  VERSION = require(path.join(REPO_ROOT, 'package.json')).version || '1.0.1';
+} catch (_) {}
+
 // ANSI Colors
 const RESET = '\x1b[0m';
 const BOLD = '\x1b[1m';
@@ -27,7 +32,7 @@ const GRAY = '\x1b[90m';
 
 function printBanner() {
   console.log(`
-${CYAN}${BOLD}🪐 Everything Gemini (${GREEN}everything-gemini${CYAN}) v1.0.1${RESET}
+${CYAN}${BOLD}🪐 Everything Gemini (${GREEN}everything-gemini${CYAN}) v${VERSION}${RESET}
 ${GRAY}The open-source agent harness & multi-agent orchestrator for Google Gemini & Antigravity${RESET}
 `);
 }
@@ -39,10 +44,13 @@ function printHelp() {
   console.log(`${BOLD}COMMANDS:${RESET}`);
   console.log(`  ${GREEN}doctor${RESET}                      Inspect system, AGY surfaces, and configuration health`);
   console.log(`  ${GREEN}install${RESET} [options]           Install everything-gemini profiles into workspace or globally`);
+  console.log(`  ${GREEN}init${RESET} [options]              Initialize everything-gemini in current workspace`);
   console.log(`  ${GREEN}list${RESET}                        Show all available skills, rules, hooks, and plugins`);
   console.log(`  ${GREEN}new-skill${RESET} <name>            Scaffold a new progressive-disclosure skill`);
   console.log(`  ${GREEN}new-agent${RESET} <name>            Scaffold a new scoped subagent specification`);
-  console.log(`  ${GREEN}add${RESET} <type> <name>           Add a specific skill, rule, or plugin to workspace`);
+  console.log(`  ${GREEN}add${RESET} <type> <name>           Add a specific skill, agent, or plugin to workspace`);
+  console.log(`  ${GREEN}remove${RESET} <type> <name>        Remove a specific skill, agent, or plugin from workspace`);
+  console.log(`  ${GREEN}test-skill${RESET} <name>           Validate a specific skill frontmatter & scripts`);
   console.log(`  ${GREEN}validate${RESET}                    Run self-test on frontmatter, JSON schemas & hooks`);
   console.log(`  ${GREEN}help${RESET}                        Show this help message\n`);
   console.log(`${BOLD}OPTIONS for 'install':${RESET}`);
@@ -141,7 +149,33 @@ function listComponents() {
         const match = content.match(/description:\s*>?-?\s*([^\n\r]+)/);
         if (match) desc = match[1].trim();
       }
-      console.log(`  ${BOLD}${skill.padEnd(24)}${RESET} ${GRAY}${desc}${RESET}`);
+      console.log(`  ${BOLD}${skill.padEnd(28)}${RESET} ${GRAY}${desc}${RESET}`);
+    }
+  }
+
+  // Also scan plugin skills
+  const pluginsDirForSkills = path.join(REPO_ROOT, 'plugins');
+  if (fs.existsSync(pluginsDirForSkills)) {
+    const plugins = fs.readdirSync(pluginsDirForSkills, { withFileTypes: true })
+      .filter(d => d.isDirectory())
+      .map(d => d.name);
+    for (const plugin of plugins) {
+      const pSkillsDir = path.join(pluginsDirForSkills, plugin, 'skills');
+      if (fs.existsSync(pSkillsDir)) {
+        const pSkills = fs.readdirSync(pSkillsDir, { withFileTypes: true })
+          .filter(d => d.isDirectory())
+          .map(d => d.name);
+        for (const skill of pSkills) {
+          const skillMd = path.join(pSkillsDir, skill, 'SKILL.md');
+          let desc = 'No description';
+          if (fs.existsSync(skillMd)) {
+            const content = fs.readFileSync(skillMd, 'utf8');
+            const match = content.match(/description:\s*>?-?\s*([^\n\r]+)/);
+            if (match) desc = match[1].trim();
+          }
+          console.log(`  ${BOLD}${skill.padEnd(28)}${RESET} ${CYAN}[${plugin}]${RESET} ${GRAY}${desc}${RESET}`);
+        }
+      }
     }
   }
 
@@ -472,6 +506,153 @@ Return structured report to parent agent:
   console.log(`  📄 ${targetFile}\n`);
 }
 
+function addComponent(type, name) {
+  if (!type || !name) {
+    console.error(`${RED}Usage: everything-gemini add <skill|agent|plugin> <name>${RESET}`);
+    process.exit(1);
+  }
+
+  const cleanName = name.trim().toLowerCase();
+  const targetWorkspace = path.join(WORKSPACE_DIR, '.agents');
+  if (!fs.existsSync(targetWorkspace)) {
+    fs.mkdirSync(targetWorkspace, { recursive: true });
+  }
+
+  if (type === 'skill') {
+    const src = path.join(REPO_ROOT, 'skills', cleanName);
+    if (!fs.existsSync(src)) {
+      console.error(`${RED}Skill '${cleanName}' not found in catalog.${RESET}`);
+      process.exit(1);
+    }
+    const dest = path.join(targetWorkspace, 'skills', cleanName);
+    copyRecursiveSync(src, dest);
+    console.log(`${GREEN}✔ Added skill '${cleanName}' to ${dest}${RESET}`);
+  } else if (type === 'agent') {
+    const src = path.join(REPO_ROOT, 'agents', `${cleanName}.md`);
+    if (!fs.existsSync(src)) {
+      console.error(`${RED}Agent '${cleanName}' not found in catalog.${RESET}`);
+      process.exit(1);
+    }
+    const destDir = path.join(targetWorkspace, 'agents');
+    fs.mkdirSync(destDir, { recursive: true });
+    fs.copyFileSync(src, path.join(destDir, `${cleanName}.md`));
+    console.log(`${GREEN}✔ Added agent '${cleanName}' to ${destDir}${RESET}`);
+  } else if (type === 'plugin') {
+    const src = path.join(REPO_ROOT, 'plugins', cleanName);
+    if (!fs.existsSync(src)) {
+      console.error(`${RED}Plugin '${cleanName}' not found in catalog.${RESET}`);
+      process.exit(1);
+    }
+    const dest = path.join(targetWorkspace, 'plugins', cleanName);
+    copyRecursiveSync(src, dest);
+    console.log(`${GREEN}✔ Added plugin '${cleanName}' to ${dest}${RESET}`);
+  } else {
+    console.error(`${RED}Unknown type '${type}'. Use: skill, agent, or plugin.${RESET}`);
+    process.exit(1);
+  }
+}
+
+function removeComponent(type, name) {
+  if (!type || !name) {
+    console.error(`${RED}Usage: everything-gemini remove <skill|agent|plugin> <name>${RESET}`);
+    process.exit(1);
+  }
+
+  const cleanName = name.trim().toLowerCase();
+  const targetWorkspace = path.join(WORKSPACE_DIR, '.agents');
+
+  if (type === 'skill') {
+    const dest = path.join(targetWorkspace, 'skills', cleanName);
+    if (!fs.existsSync(dest)) {
+      console.log(`${YELLOW}Skill '${cleanName}' is not installed in ${dest}${RESET}`);
+      return;
+    }
+    fs.rmSync(dest, { recursive: true, force: true });
+    console.log(`${GREEN}✔ Removed skill '${cleanName}' from workspace.${RESET}`);
+  } else if (type === 'agent') {
+    const dest = path.join(targetWorkspace, 'agents', `${cleanName}.md`);
+    if (!fs.existsSync(dest)) {
+      console.log(`${YELLOW}Agent '${cleanName}' is not installed in ${dest}${RESET}`);
+      return;
+    }
+    fs.unlinkSync(dest);
+    console.log(`${GREEN}✔ Removed agent '${cleanName}' from workspace.${RESET}`);
+  } else if (type === 'plugin') {
+    const dest = path.join(targetWorkspace, 'plugins', cleanName);
+    if (!fs.existsSync(dest)) {
+      console.log(`${YELLOW}Plugin '${cleanName}' is not installed in ${dest}${RESET}`);
+      return;
+    }
+    fs.rmSync(dest, { recursive: true, force: true });
+    console.log(`${GREEN}✔ Removed plugin '${cleanName}' from workspace.${RESET}`);
+  } else {
+    console.error(`${RED}Unknown type '${type}'. Use: skill, agent, or plugin.${RESET}`);
+    process.exit(1);
+  }
+}
+
+function testSkill(name) {
+  if (!name) {
+    console.error(`${RED}Usage: everything-gemini test-skill <skill-name>${RESET}`);
+    process.exit(1);
+  }
+  const cleanName = name.trim().toLowerCase();
+  const skillDir = path.join(REPO_ROOT, 'skills', cleanName);
+  const skillMd = path.join(skillDir, 'SKILL.md');
+
+  if (!fs.existsSync(skillMd)) {
+    console.error(`${RED}✖ SKILL.md not found for skill '${cleanName}' at ${skillDir}${RESET}`);
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(skillMd, 'utf8');
+  console.log(`${BOLD}🔍 Validating skill: [${CYAN}${cleanName}${RESET}${BOLD}]...${RESET}`);
+
+  if (!content.startsWith('---')) {
+    console.error(`  ${RED}✖ Missing YAML frontmatter start (---)${RESET}`);
+    process.exit(1);
+  }
+
+  const parts = content.split('---');
+  if (parts.length < 3) {
+    console.error(`  ${RED}✖ Malformed YAML frontmatter boundary${RESET}`);
+    process.exit(1);
+  }
+
+  const frontmatter = parts[1];
+  const nameMatch = frontmatter.match(/name:\s*([^\n\r]+)/);
+  const descMatch = frontmatter.match(/description:\s*>?-?\s*([^\n\r]+)/);
+
+  if (!nameMatch) {
+    console.error(`  ${RED}✖ Missing 'name' field in frontmatter${RESET}`);
+    process.exit(1);
+  }
+  console.log(`  ${GREEN}✔${RESET} Name field: ${BOLD}${nameMatch[1].trim()}${RESET}`);
+
+  if (!descMatch) {
+    console.error(`  ${RED}✖ Missing 'description' field in frontmatter${RESET}`);
+    process.exit(1);
+  }
+  console.log(`  ${GREEN}✔${RESET} Description trigger: ${GRAY}${descMatch[1].trim()}${RESET}`);
+
+  const scriptsDir = path.join(skillDir, 'scripts');
+  if (fs.existsSync(scriptsDir)) {
+    const scripts = fs.readdirSync(scriptsDir).filter(f => f.endsWith('.sh'));
+    for (const s of scripts) {
+      const fullPath = path.join(scriptsDir, s);
+      const stat = fs.statSync(fullPath);
+      const isExec = (stat.mode & 0o111) !== 0;
+      if (!isExec) {
+        console.error(`  ${RED}✖ Script ${s} is not executable. Run chmod +x${RESET}`);
+        process.exit(1);
+      }
+      console.log(`  ${GREEN}✔${RESET} Script executable: ${s}`);
+    }
+  }
+
+  console.log(`\n${GREEN}${BOLD}✨ Skill '${cleanName}' passed all validation checks!${RESET}\n`);
+}
+
 // CLI Argument Parsing
 const args = process.argv.slice(2);
 const command = args[0] || 'help';
@@ -489,6 +670,16 @@ switch (command) {
   case 'new-agent':
     scaffoldAgent(args[1]);
     break;
+  case 'add':
+    addComponent(args[1], args[2]);
+    break;
+  case 'remove':
+    removeComponent(args[1], args[2]);
+    break;
+  case 'test-skill':
+    testSkill(args[1]);
+    break;
+  case 'init':
   case 'install': {
     let profile = 'developer';
     let isGlobal = false;

package/docs/LAUNCH_KIT.md

@@ -0,0 +1,156 @@
+# 🚀 Everything Gemini Launch & Marketing Kit
+
+This launch kit contains ready-to-post announcements, social copy, and submission templates for **Everything Gemini (`everything-gemini`)**.
+
+---
+
+## 🐦 1. X (Twitter) Launch
+
+### Option A: The High-Impact Single Tweet (251 chars)
+```text
+🪐 Everything Gemini v1.1.0 is live!
+
+The open-source multi-agent harness for Google Antigravity & Gemini 3.8.
+
+⚡ 27 lazy-loaded skills (Multimodal, RAG, 2M context caching)
+🤖 6 scoped subagents
+🛡️ GeminiShield safety gates
+
+⭐ https://github.com/salmandev/everything-gemini
+```
+
+### Option B: The 4-Part Viral Thread
+
+**Tweet 1 (Hook)**:
+```text
+Ever notice how AI coding agents suffer from context bloat and catastrophic edits without structured workflows?
+
+Claude Code has ECC. Now, Google Antigravity & Gemini have Everything Gemini.
+
+Introducing Everything Gemini 🪐 — the open-source agent harness & multi-agent orchestrator. 🧵👇
+```
+
+**Tweet 2 (Core Innovations)**:
+```text
+Unlike traditional prompt dumps, Everything Gemini uses strict Progressive Disclosure:
+- 🧠 27 lazy-loaded skills load runbooks on demand (saving up to 85% token overhead).
+- ⚡ Exploits Gemini's 2M token context with static prefix caching.
+- 👁️ Multimodal visual QA with automated WebP recordings.
+```
+
+**Tweet 3 (Fleet & Safety)**:
+```text
+It comes with a dedicated 6-subagent fleet and deterministic lifecycle safety:
+- 🤖 Planner, Code Reviewer, Build Repair, Browser QA, Security Auditor & Architect.
+- 🛡️ GeminiShield PreToolUse gates that intercept `rm -rf`, `DROP TABLE`, or force pushes before they execute.
+```
+
+**Tweet 4 (Call to Action)**:
+```text
+Zero setup. Install anywhere in 1 second:
+$ npx everything-gemini install
+
+🌐 Interactive Showcase: https://salmandev.github.io/everything-gemini/
+💻 GitHub (Apache 2.0): https://github.com/salmandev/everything-gemini
+📦 NPM: https://www.npmjs.com/package/everything-gemini
+
+Give it a ⭐ and let me know what skills to add next!
+```
+
+---
+
+## 🔴 2. Reddit Post (`r/GoogleGeminiAI`, `r/LocalLLaMA`, `r/MachineLearning`)
+
+**Title**:
+```text
+Everything Gemini: Open-source multi-agent harness, 27 progressive skills & subagent fleet for Google Antigravity
+```
+
+**Body**:
+```markdown
+Hey everyone!
+
+With Google Antigravity rolling out across Desktop 2.0, IDE, and CLI surfaces, I built **Everything Gemini (`everything-gemini`)** — an open-source agent harness and multi-agent orchestrator inspired by the architectural concepts of Everything Claude Code (ECC), but re-engineered from the ground up for Gemini 3.8 and Google Antigravity.
+
+### 🌟 Key Highlights
+
+1. **27 Lazy-Loaded Progressive Disclosure Skills**:
+   - **Frontier**: Native multimodal UI testing, 2M token prefix context caching, real-time Google Search grounding, RAG with re-ranking (`rag-architect`), and typed function calling schemas.
+   - **Cloud & Backend**: Supabase RLS policies, Cloudflare Workers & D1 SQL, Kubernetes manifests with HPA, Stripe webhook verification, and Next.js App Router.
+   - **Engineering**: Test-Driven Development (Red-Green-Refactor), automated git bisect debugging, GitHub Ops, and performance profiling.
+
+2. **6 Scoped Subagents (`agents/`)**:
+   - Specialized specifications for **Planner**, **Code Reviewer**, **Build Repair**, **Browser QA**, **Security Auditor**, and **Architect** with formal task delegation and boundary protocols.
+
+3. **Deterministic Safety Gates (GeminiShield)**:
+   - Lifecycle hooks that intercept destructive shell commands (`rm -rf`, raw DROP TABLE, git force pushes) before execution.
+
+4. **Zero-Dependency CLI & npm Distribution**:
+   - Instant installation: `npx everything-gemini install`
+   - Scaffolding commands: `everything-gemini new-skill` and `everything-gemini new-agent`
+
+---
+
+* 🌐 **Live Interactive Catalog**: [https://salmandev.github.io/everything-gemini/](https://salmandev.github.io/everything-gemini/)
+* 💻 **GitHub (Apache 2.0)**: [https://github.com/salmandev/everything-gemini](https://github.com/salmandev/everything-gemini)
+* 📦 **NPM Registry**: [https://www.npmjs.com/package/everything-gemini](https://www.npmjs.com/package/everything-gemini)
+
+Feedback, issues, and contributions for new skills are very welcome!
+```
+
+---
+
+## 🟧 3. Hacker News (Show HN)
+
+**Title**:
+```text
+Show HN: Everything Gemini – Multi-agent harness & skills for Google Antigravity
+```
+
+**URL**:
+```text
+https://salmandev.github.io/everything-gemini/
+```
+
+**First Comment (OP Context)**:
+```text
+Hi HN!
+
+As coding agents move beyond simple single-turn prompts into multi-step autonomous execution, they face two key bottlenecks: context window bloat (dumping endless system prompts) and lack of deterministic safety guardrails.
+
+Inspired by Affan Mustafa's Everything Claude Code (ECC), I built Everything Gemini (everything-gemini) specifically optimized for Google Antigravity and Gemini's architecture:
+
+- Progressive Disclosure: The agent only sees metadata in its system prompt; complete procedural playbooks (27 skills) are lazy-loaded only when triggered by user intent.
+- Massive Context Economics: Harnesses Gemini's 1M-2M token window with static prefix caching (~75% cost reduction).
+- Scoped Subagent Fleet: Discrete roles for Planner, Reviewer, Browser QA, Build Repair, Security, and Architect.
+- GeminiShield: Deterministic PreToolUse lifecycle gates intercepting catastrophic commands.
+
+Code is Apache 2.0 on GitHub: https://github.com/salmandev/everything-gemini
+Package is published on NPM: npx everything-gemini install
+
+Would love to hear your thoughts and feedback!
+```
+
+---
+
+## 💼 4. LinkedIn Post
+
+```text
+🚀 Excited to launch Everything Gemini (everything-gemini) — an open-source multi-agent harness and performance suite for Google Antigravity and Gemini 3.8!
+
+As AI coding platforms evolve, developers need structured engineering workflows, deterministic safety rails, and context-efficient architectures.
+
+🪐 Everything Gemini delivers:
+✅ 27 Progressive Disclosure Skills (Multimodal vision, 2M context caching, RAG with re-ranking, Supabase, Cloudflare Workers, GitHub Ops)
+✅ 6 Scoped Subagents with formal delegation boundaries (Planner, Reviewer, QA, Repair, Security, Architect)
+✅ GeminiShield deterministic lifecycle safety hooks
+✅ 1-second setup: `npx everything-gemini install`
+
+Check out our interactive showcase catalog:
+👉 https://salmandev.github.io/everything-gemini/
+
+GitHub repository:
+👉 https://github.com/salmandev/everything-gemini
+
+#AI #GoogleGemini #GoogleAntigravity #SoftwareEngineering #OpenSource #DevTools #MachineLearning
+```