everything-gemini 0.0.0-stage → 1.0.1

package/mcp/README.md

@@ -0,0 +1,41 @@
+# Model Context Protocol (MCP) in Antigravity
+
+The Model Context Protocol (MCP) is an open standard enabling secure, bidirectional tool and resource sharing between Antigravity and external services.
+
+## Configuration Locations
+- **Global**: `~/.gemini/config/mcp_config.json` (applies to all sessions).
+- **Workspace Project**: `.agents/mcp_config.json`.
+- **Plugin Packaged**: `plugins/<plugin_name>/mcp_config.json`.
+
+## Supported Transports
+
+### 1. Stdio (Local Process)
+Antigravity launches a local executable or Node/Python script, communicating over standard input and output:
+```json
+{
+  "mcpServers": {
+    "sqlite": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-sqlite", "./data/app.db"],
+      "env": {
+        "DB_READONLY": "true"
+      }
+    }
+  }
+}
+```
+
+### 2. SSE (Remote HTTP / Server-Sent Events)
+Antigravity connects to a remote MCP endpoint over HTTPS:
+```json
+{
+  "mcpServers": {
+    "remote-tools": {
+      "serverUrl": "https://mcp.internal.company.com/sse"
+    }
+  }
+}
+```
+
+## Tool Auto-Discovery & Execution
+Once connected, tools declared by MCP servers are automatically injected into the agent's system prompt and executed through Antigravity's Language Server. Inspect active MCP servers in the Antigravity UI via **Additional Options (...) > MCP Servers**.

package/mcp/mcp_config.example.json

@@ -0,0 +1,30 @@
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_GITHUB_PAT"
+      }
+    },
+    "sqlite": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-sqlite", "./data/app.db"],
+      "env": {
+        "DB_READONLY": "true"
+      }
+    },
+    "postgres": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-postgres", "postgresql://user:password@localhost:5432/mydb"]
+    },
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "./docs", "./src"]
+    },
+    "fetch": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-fetch"]
+    }
+  }
+}

package/package.json

@@ -1,6 +1,41 @@
 {
   "name": "everything-gemini",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "1.0.1",
+  "description": "Everything Gemini (everything-gemini) - The Ultimate Agent Harness, Multi-Agent Orchestrator & Performance Suite for Gemini & Google Antigravity",
+  "main": "bin/everything-gemini",
+  "bin": {
+    "everything-gemini": "bin/everything-gemini",
+    "egemini": "bin/everything-gemini",
+    "eagy": "bin/everything-gemini"
+  },
+  "scripts": {
+    "test": "bash scripts/validate.sh",
+    "validate": "bash scripts/validate.sh",
+    "install:core": "bash scripts/install.sh --profile core",
+    "install:dev": "bash scripts/install.sh --profile developer",
+    "install:full": "bash scripts/install.sh --profile full"
+  },
+  "keywords": [
+    "gemini",
+    "google-gemini",
+    "antigravity",
+    "agy",
+    "ai-agent",
+    "multi-agent",
+    "mcp",
+    "skills",
+    "rules",
+    "hooks",
+    "everything-gemini",
+    "egemini"
+  ],
+  "author": "Everything Antigravity Contributors",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/salmandev/everything-gemini.git"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/plugins/core/hooks.json

@@ -0,0 +1,16 @@
+{
+  "core-safety": {
+    "PreToolUse": [
+      {
+        "matcher": "run_command",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ./hooks/safety-shield/scripts/safety-gate.sh",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/plugins/core/plugin.json

@@ -0,0 +1,3 @@
+{
+  "name": "Everything Gemini Core Safety & Engineering"
+}

package/plugins/core/rules/core-practices.md

@@ -0,0 +1,5 @@
+# Core Engineering Practices
+
+- **Self-Healing Verification**: Whenever a command errors, parse the traceback before making subsequent edits.
+- **Atomic Operations**: Never leave files in half-written or unparseable states.
+- **Defensive Coding**: Validate all inputs at the boundary. Fail fast and fail clearly.

package/plugins/python-ai/plugin.json

@@ -0,0 +1,3 @@
+{
+  "name": "Everything Gemini Python & AI Systems"
+}

package/plugins/python-ai/rules/ai-agent-patterns.md

@@ -0,0 +1,5 @@
+# AI Agent & LLM Engineering Standards
+
+- **Streaming First**: Always stream LLM response tokens and reasoning thoughts for enhanced observability and interactive responsiveness.
+- **Strongly-Typed Tool Calls**: Validate tool schemas using Pydantic or TypedDict before exposing them to agents.
+- **Graceful Error Recovery**: Handle API rate limits, model overloads, and context length limits with exponential backoff and message compaction.

package/plugins/python-ai/skills/antigravity-sdk-orchestrator/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: antigravity-sdk-orchestrator
+description: >-
+  Orchestrates, configures, and tests AI agents programmatically using the official google-antigravity Python SDK. Use when automating agent pipelines or embedding Antigravity into Python services.
+---
+
+# Antigravity Python SDK Orchestrator
+
+This skill guides the programmatic orchestration of Antigravity agents using `google-antigravity`.
+
+## Setup & Installation
+
+```bash
+pip install google-antigravity
+```
+
+## Core Agent Lifecycle Pattern
+
+```python
+import asyncio
+import sys
+from google.antigravity import Agent, LocalAgentConfig, CapabilitiesConfig
+
+async def run_agent_workflow():
+    # Configure agent with specific capabilities
+    config = LocalAgentConfig(
+        system_instructions="You are an autonomous CI test auditor.",
+        capabilities=CapabilitiesConfig(), # Enables write tools if required
+    )
+
+    # Agent runs inside an async context manager
+    async with Agent(config) as agent:
+        response = await agent.chat("Audit all test files in tests/ and report missing cases.")
+
+        # Stream reasoning thoughts
+        async for thought in response.thoughts:
+            print(f"[Reasoning] {thought}")
+
+        # Stream tool calls
+        async for call in response.tool_calls:
+            print(f"[Tool Executed] {call.name}: {call.args}")
+
+        # Stream response text
+        async for token in response:
+            sys.stdout.write(token)
+            sys.stdout.flush()
+
+if __name__ == "__main__":
+    asyncio.run(run_agent_workflow())
+```
+
+## Key Architectural Notes
+- The SDK manages compiled binary discovery, tool wiring, and hook execution automatically.
+- Always use `async with Agent(config)` to guarantee clean process shutdown and sandbox deallocation.

package/plugins/security-shield/hooks.json

@@ -0,0 +1,16 @@
+{
+  "strict-security-gate": {
+    "PreToolUse": [
+      {
+        "matcher": "run_command",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ./hooks/safety-shield/scripts/safety-gate.sh",
+            "timeout": 10
+          }
+        ]
+      }
+    ]
+  }
+}

package/plugins/security-shield/plugin.json

@@ -0,0 +1,3 @@
+{
+  "name": "Everything Gemini Security Shield"
+}

package/plugins/security-shield/rules/zero-trust.md

@@ -0,0 +1,5 @@
+# Zero-Trust Security Policies
+
+- **Least Privilege Tool Execution**: Agents operate with read-only defaults unless explicit write capabilities are granted.
+- **Network Boundaries**: Outbound network requests require explicit authorization unless calling approved APIs in the allowlist.
+- **Sandboxed Execution**: Destructive system utilities are restricted to isolated containers or sandboxes.

package/plugins/web-fullstack/plugin.json

@@ -0,0 +1,3 @@
+{
+  "name": "Everything Gemini Web Fullstack Suite"
+}

package/plugins/web-fullstack/rules/frontend-standards.md

@@ -0,0 +1,5 @@
+# Frontend Engineering Standards
+
+- **Accessible HTML (a11y)**: Use semantic HTML5 elements (`<nav>`, `<main>`, `<article>`, `<section>`, `<button>`). Never use `<div onClick="...">` without keyboard accessibility.
+- **Visual Excellence**: Avoid plain, generic color schemes. Use curated palettes (HSL/OKLCH), subtle gradients, and smooth micro-animations.
+- **Zero Layout Shifts**: Always specify dimensions (`width`, `height`) on images and video embeds.

package/plugins/web-fullstack/skills/responsive-design/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: responsive-design
+description: >-
+  Guides creating mobile-responsive layouts, fluid typography, flex/grid structures, and cross-browser testing. Use when designing or debugging responsive user interfaces.
+---
+
+# Responsive Design & Layout Engineering
+
+This skill structures the creation of responsive, cross-device interfaces.
+
+## Guidelines
+
+1. **Mobile-First CSS**: Define baseline mobile styles without media queries, then use `min-width` queries for larger viewports:
+   ```css
+   .container { width: 100%; padding: 1rem; }
+   @media (min-width: 768px) { .container { max-width: 720px; } }
+   @media (min-width: 1024px) { .container { max-width: 960px; } }
+   ```
+2. **Fluid Typography**: Use `clamp()` for headings that adapt gracefully between screen sizes:
+   ```css
+   font-size: clamp(1.5rem, 2.5vw + 1rem, 3rem);
+   ```
+3. **Verify with Browser Subagent**: Use `browser_subagent` to resize the browser window across standard breakpoints (375px mobile, 768px tablet, 1440px desktop) and confirm that navigation drawers and flex wraps behave cleanly.

package/rules/common/AGENTS.md

@@ -0,0 +1,30 @@
+# Antigravity Core Behavioral Standards (everything-gemini)
+
+These standards govern all Antigravity agent interactions within this project.
+
+## 1. Prime Directives
+
+1. **Verify Before Asserting (Zero Hallucination)**:
+   - Never assume file structures, function signatures, or dependencies exist without inspecting them first.
+   - Use `view_file`, `grep_search`, or `list_dir` to read actual code before proposing or applying changes.
+
+2. **Proactive Verification Loop**:
+   - Every modification MUST be followed by automated verification (running tests, linters, or typecheckers).
+   - If a command fails, inspect the error output immediately and fix the root cause rather than guessing.
+
+3. **Minimal Surgical Diffs**:
+   - Preserve all existing code formatting, comments, and docstrings unrelated to your task.
+   - Use targeted edit tools (`replace_file_content` or `multi_replace_file_content`) instead of overwriting whole files whenever possible.
+
+4. **Progressive Disclosure Discipline**:
+   - Keep conversation context lean. Rely on on-demand skills in `.agents/skills/` and reference documents in `references/`.
+   - Use rich Markdown artifacts (`.md`) in the brain directory for long-form reports and architecture designs.
+
+5. **Clickable Markdown Navigation**:
+   - Always format file paths and symbols as clickable Markdown links with the `file://` scheme: `[filename](file:///absolute/path/to/file)`.
+
+## 2. Terminal & Execution Safety
+
+- Never execute commands with unchecked wildcards on destructive operations (`rm -rf *`, `git reset --hard`, `DROP DATABASE`).
+- Run long-running dev servers or watchers with `IsDaemon: true` or appropriate background flags.
+- For interactive testing, leverage the built-in `browser_subagent` for full automated visual validation.

package/rules/common/GEMINI.md

@@ -0,0 +1,30 @@
+# Antigravity Core Behavioral Standards (everything-gemini)
+
+These standards govern all Antigravity agent interactions within this project.
+
+## 1. Prime Directives
+
+1. **Verify Before Asserting (Zero Hallucination)**:
+   - Never assume file structures, function signatures, or dependencies exist without inspecting them first.
+   - Use `view_file`, `grep_search`, or `list_dir` to read actual code before proposing or applying changes.
+
+2. **Proactive Verification Loop**:
+   - Every modification MUST be followed by automated verification (running tests, linters, or typecheckers).
+   - If a command fails, inspect the error output immediately and fix the root cause rather than guessing.
+
+3. **Minimal Surgical Diffs**:
+   - Preserve all existing code formatting, comments, and docstrings unrelated to your task.
+   - Use targeted edit tools (`replace_file_content` or `multi_replace_file_content`) instead of overwriting whole files whenever possible.
+
+4. **Progressive Disclosure Discipline**:
+   - Keep conversation context lean. Rely on on-demand skills in `.agents/skills/` and reference documents in `references/`.
+   - Use rich Markdown artifacts (`.md`) in the brain directory for long-form reports and architecture designs.
+
+5. **Clickable Markdown Navigation**:
+   - Always format file paths and symbols as clickable Markdown links with the `file://` scheme: `[filename](file:///absolute/path/to/file)`.
+
+## 2. Terminal & Execution Safety
+
+- Never execute commands with unchecked wildcards on destructive operations (`rm -rf *`, `git reset --hard`, `DROP DATABASE`).
+- Run long-running dev servers or watchers with `IsDaemon: true` or appropriate background flags.
+- For interactive testing, leverage the built-in `browser_subagent` for full automated visual validation.

package/rules/languages/golang.md

@@ -0,0 +1,10 @@
+# Go (Golang) Engineering Standards
+
+Apply these rules when writing or refactoring Go code.
+
+## 1. Idiomatic Go
+
+- **Explicit Error Handling**: Never ignore error returns (`_`). Always inspect `err != nil`. Wrap errors with context using `fmt.Errorf("failed to process order %s: %w", id, err)`.
+- **Context Propagation**: Pass `ctx context.Context` as the first parameter to functions that perform I/O, network calls, or long-running computations.
+- **Table-Driven Tests**: Organize unit tests using table-driven test patterns with `t.Run(tc.name, func(t *testing.T) { ... })`.
+- **Concurrency Safety**: Protect shared state with `sync.Mutex` or channels. Run tests with `-race` flag to detect race conditions.

package/rules/languages/python.md

@@ -0,0 +1,16 @@
+# Python Engineering Standards
+
+Apply these rules when reading, writing, or refactoring Python code.
+
+## 1. Modern Python (3.11+)
+
+- **Type Hints Everywhere**: Every function must specify parameter types and return type annotations.
+- **PEP 604 & 695**: Use modern union syntax (`str | None` instead of `Optional[str]`) and modern type aliases.
+- **Pydantic v2**: Use `pydantic.BaseModel` with strict field validations for data transfer objects (DTOs) and API payloads.
+- **Formatting & Linting**: Follow PEP 8 via `ruff` and `black`. Zero unused imports or unformatted blocks.
+
+## 2. Robust Async & Concurrency
+
+- **Structured Concurrency**: Use `asyncio.TaskGroup()` (Python 3.11+) rather than unchecked `asyncio.gather()` whenever possible to prevent task leaks.
+- **Context Managers**: Wrap network sessions, database connections, and file handles in `async with` or `with` blocks.
+- **Exception Chaining**: Always use `raise CustomError(...) from err` to preserve stack traces.

package/rules/languages/typescript.md

@@ -0,0 +1,18 @@
+# TypeScript Engineering Standards
+
+Apply these rules when reading, writing, or refactoring TypeScript code.
+
+## 1. Type Safety & Rigor
+
+- **Strict Mode Always**: Ensure `strict: true` in `tsconfig.json`.
+- **Zero `any`**: Never use `any`. Use `unknown` with runtime type assertions, type predicates (`val is T`), or schema validators.
+- **Explicit Function Signatures**: All exported functions, methods, and API handlers must have explicit return types.
+- **Discriminated Unions**: Prefer discriminated unions over optional fields or loosely typed objects for state management.
+- **Runtime Validation**: Use Zod, Valibot, or ArkType to parse and validate untrusted input (API responses, environment variables, user submissions).
+
+## 2. Modern Syntax & Architecture
+
+- **Pure ESM**: Use ES modules (`import`/`export`) with explicit `.js` extensions where required by Node ESM.
+- **Immutable by Default**: Use `readonly` arrays, `as const`, and `Readonly<T>` for static configurations and state objects.
+- **Async/Await**: Avoid raw `.then()` / `.catch()` chains. Use standard `async`/`await` with structured `try`/`catch` handling.
+- **Path Aliases**: Maintain clean import trees using project path aliases (e.g. `@/components/`, `@/lib/`).

package/rules/paradigms/security-hardened.md

@@ -0,0 +1,17 @@
+# Security & Hardening Protocol
+
+Security rules enforced for all agent code generation and execution.
+
+## 1. Zero Secret Leakage
+- Never print, log, or commit API keys, tokens, certificates, or credentials.
+- Always load secrets via environment variables (`process.env`, `os.environ`).
+- Ensure `.env` files and secret patterns are listed in `.gitignore`.
+
+## 2. Command & Injection Defense
+- Never execute shell commands by concatenating unsanitized user strings.
+- Always use parameterized queries for SQL/NoSQL databases to prevent SQL injection.
+- Validate paths with `path.resolve` and verify they remain within the authorized workspace directory to prevent directory traversal.
+
+## 3. Dependency Security
+- Review new packages before adding them to `package.json` or `pyproject.toml`.
+- Run automated vulnerability audits (`npm audit`, `pip-audit`, `govulncheck`) on dependencies.

package/rules/paradigms/tdd.md

@@ -0,0 +1,19 @@
+# Test-Driven Development (TDD) Protocol
+
+Enforce this workflow when developing features, fixing bugs, or refactoring code.
+
+## The TDD Iron Law
+
+> **Never write production code unless an existing test is currently failing because that code does not exist.**
+
+### Phase 1: RED (Reproduce & Specify)
+1. Write a minimal, focused unit or integration test describing the desired behavior or reproducing the reported bug.
+2. Run the test suite and verify that the test fails for the expected reason (not due to syntax or import errors).
+
+### Phase 2: GREEN (Minimal Implementation)
+1. Write the absolute minimum production code required to make the failing test pass.
+2. Run the test suite and ensure all tests pass. Do not write premature optimizations or unrelated code.
+
+### Phase 3: REFACTOR (Clean & Harden)
+1. Clean up duplicated logic, improve naming, extract helper functions, and enforce type safety.
+2. Re-run tests after every micro-refactor to ensure zero regressions.

package/scripts/install.ps1

@@ -0,0 +1,26 @@
+# Everything Gemini (everything-gemini) Installer for Windows PowerShell
+param (
+    [string]$Profile = "developer",
+    [switch]$Global = $false,
+    [string]$Workspace = ""
+)
+
+Write-Host "🪐 Everything Gemini (everything-gemini) Installer" -ForegroundColor Cyan
+Write-Host "The premier agent harness & customization suite for Google Antigravity`n" -ForegroundColor Gray
+
+if (-not (Test-Path "bin\everything-gemini")) {
+    Write-Host "Downloading latest everything-gemini release..." -ForegroundColor Yellow
+    $tempDir = [System.IO.Path]::Combine([System.IO.Path]::GetTempPath(), [System.IO.Path]::GetRandomFileName())
+    git clone --depth 1 https://github.com/salmandev/everything-gemini.git $tempDir
+    Set-Location $tempDir
+}
+
+$cliArgs = @("install", "--profile", $Profile)
+if ($Global) {
+    $cliArgs += "--global"
+}
+if ($Workspace -ne "") {
+    $cliArgs += @("--workspace", $Workspace)
+}
+
+node bin\everything-gemini @cliArgs

package/scripts/install.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+# Everything Gemini (everything-gemini) Installer
+# Fast setup script for macOS and Linux
+
+BOLD="\033[1m"
+GREEN="\033[32m"
+CYAN="\033[36m"
+YELLOW="\033[33m"
+RESET="\033[0m"
+
+echo -e "${CYAN}${BOLD}"
+echo "  🪐 Everything Gemini (everything-gemini) Installer"
+echo "  The premier agent harness & customization suite for Google Antigravity"
+echo -e "${RESET}"
+
+PROFILE="developer"
+INSTALL_GLOBAL=false
+TARGET_DIR=""
+
+while [[ "$#" -gt 0 ]]; do
+  case $1 in
+    --profile) PROFILE="$2"; shift ;;
+    --global) INSTALL_GLOBAL=true ;;
+    --workspace) TARGET_DIR="$2"; shift ;;
+    *) echo "Unknown parameter passed: $1"; exit 1 ;;
+  esac
+  shift
+done
+
+# If run directly via curl pipe, clone into temporary directory or clone repo
+if [ ! -f "bin/everything-gemini" ]; then
+  echo -e "${YELLOW}Downloading latest everything-gemini release...${RESET}"
+  TMP_DIR=$(mktemp -d)
+  git clone --depth 1 https://github.com/salmandev/everything-gemini.git "$TMP_DIR/everything-gemini" 2>/dev/null || {
+    echo "Failed to clone repository. Please ensure git is installed."
+    exit 1
+  }
+  cd "$TMP_DIR/everything-gemini"
+fi
+
+# Run node installer
+CLI_ARGS="install --profile $PROFILE"
+if [ "$INSTALL_GLOBAL" = true ]; then
+  CLI_ARGS="$CLI_ARGS --global"
+fi
+if [ -n "$TARGET_DIR" ]; then
+  CLI_ARGS="$CLI_ARGS --workspace $TARGET_DIR"
+fi
+
+./bin/everything-gemini $CLI_ARGS

package/scripts/validate.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+set -eo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+ERRORS=0
+
+echo "🔍 Validating Everything Gemini (everything-gemini) repository..."
+
+# 1. Validate SKILL.md Frontmatter
+echo "  [1/4] Checking Skills & YAML frontmatter..."
+SKILL_FILES=$(find "$REPO_ROOT/skills" "$REPO_ROOT/plugins" -name "SKILL.md" 2>/dev/null || true)
+
+for skill_file in $SKILL_FILES; do
+  rel_path="${skill_file#$REPO_ROOT/}"
+  
+  # Check for YAML frontmatter delimiters
+  if ! head -n 1 "$skill_file" | grep -q "^---"; then
+    echo "    ❌ ERROR: $rel_path is missing leading '---' frontmatter delimiter"
+    ERRORS=$((ERRORS + 1))
+    continue
+  fi
+
+  # Check for name field
+  if ! grep -q "^name:" "$skill_file"; then
+    echo "    ❌ ERROR: $rel_path is missing 'name:' field in frontmatter"
+    ERRORS=$((ERRORS + 1))
+  fi
+
+  # Check for description field
+  if ! grep -q "^description:" "$skill_file"; then
+    echo "    ❌ ERROR: $rel_path is missing 'description:' field in frontmatter"
+    ERRORS=$((ERRORS + 1))
+  fi
+  
+  echo "    ✔ $rel_path"
+done
+
+# 2. Validate JSON Syntax
+echo "  [2/4] Validating JSON files..."
+JSON_FILES=$(find "$REPO_ROOT" -name "*.json" ! -path "*/node_modules/*" 2>/dev/null || true)
+
+for json_file in $JSON_FILES; do
+  rel_path="${json_file#$REPO_ROOT/}"
+  if ! node -e "JSON.parse(fs.readFileSync('$json_file', 'utf8'))" 2>/dev/null; then
+    echo "    ❌ ERROR: Invalid JSON in $rel_path"
+    ERRORS=$((ERRORS + 1))
+  else
+    echo "    ✔ $rel_path"
+  fi
+done
+
+# 3. Validate Shell Scripts Executability
+echo "  [3/4] Verifying script permissions..."
+SH_FILES=$(find "$REPO_ROOT/scripts" "$REPO_ROOT/hooks" "$REPO_ROOT/skills" -name "*.sh" 2>/dev/null || true)
+
+for sh_file in $SH_FILES; do
+  rel_path="${sh_file#$REPO_ROOT/}"
+  if [ ! -x "$sh_file" ]; then
+    echo "    ⚠️ Fixing executable bit on: $rel_path"
+    chmod +x "$sh_file"
+  fi
+  echo "    ✔ $rel_path (executable)"
+done
+
+# 4. Summary
+echo "  [4/4] Validation Summary"
+if [ "$ERRORS" -gt 0 ]; then
+  echo "❌ Validation failed with $ERRORS error(s)."
+  exit 1
+else
+  echo "✨ All validations passed successfully! everything-gemini is pristine."
+  exit 0
+fi

package/skills/api-craftsman/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: api-craftsman
+description: >-
+  Designs, specifies, and reviews production-grade REST APIs, OpenAPI 3.1 specifications, gRPC protobuf schemas, and GraphQL types. Use when creating or updating API contracts.
+---
+
+# API Craftsman
+
+This skill enforces industry-leading API design principles, contract-first development, and consistent versioning.
+
+## API Design Principles
+
+### 1. Resource-Oriented REST
+- **Nouns, Not Verbs**: Use `/api/v1/orders` instead of `/api/v1/getOrders`.
+- **HTTP Methods Semantics**:
+  - `GET`: Safe, idempotent retrieval.
+  - `POST`: Non-idempotent creation or processing.
+  - `PUT`: Complete idempotent replacement.
+  - `PATCH`: Partial modification.
+  - `DELETE`: Idempotent removal.
+- **Consistent Response Envelopes**:
+  ```json
+  {
+    "data": { ... },
+    "error": null,
+    "meta": { "page": 1, "pageSize": 20, "total": 100 }
+  }
+  ```
+
+### 2. Contract-First OpenAPI 3.1
+Define schemas in OpenAPI 3.1 YAML before writing backend route handlers. Validate schemas using Zod or Pydantic models on the server.
+
+### 3. Error Standard (RFC 7807)
+Always return errors conforming to the Problem Details specification:
+```json
+{
+  "type": "https://api.example.com/errors/invalid-argument",
+  "title": "Invalid Argument",
+  "status": 400,
+  "detail": "Field 'email' must be a valid email address.",
+  "instance": "/orders/123/items"
+}
+```
+
+For OpenAPI 3.1 sample specifications, see [examples/openapi-spec.yaml](./examples/openapi-spec.yaml).