everything-gemini 2.0.0 → 2.2.0

package/docs/LAUNCH_KIT_v2.1.0.md

@@ -0,0 +1,118 @@
+# 🚀 Everything Gemini v2.1.0 Launch Kit
+## Google Research Harness² Integration & Google Family Handshake
+
+Use these pre-crafted, platform-optimized announcements to broadcast **Everything Gemini (`everything-gemini`) v2.1.0** across LinkedIn, X (Twitter), Reddit, and developer communities.
+
+---
+
+## 💼 LinkedIn Post
+
+**Headline:** Google just open-sourced Harness² for agent optimization. Today, Everything Gemini becomes the first open-source agent harness to handshake with it.
+
+When Google Research published *Harness²: Recursive Agent Harnessing for an Open World* (arXiv:2610.14224), it redefined how we optimize autonomous AI agents.
+
+Instead of retraining or fine-tuning model weights, Harness² freezes the foundation model and recursively optimizes the **8 file-based harness surfaces** that govern agent cognition:
+1. Prompts
+2. Guardrails
+3. Memory
+4. Tool Guidance
+5. Scoped Subagents
+6. Progressive Skills
+7. Scripts & Probe Gates
+8. Plugins
+
+Everything Gemini (`everything-gemini`) v2.1.0 is engineered to handshake directly with Harness² out of the box!
+
+🔥 **What's New in v2.1.0:**
+- 🔬 **Harness² Recursive Optimization**: Test-time recursive agent optimization implementing the **Propose-Probe-Compose** loop.
+- 🌊 **Google Agentic Flow Orchestration**: State-machine engine managing cyclic multi-agent loops, conditional branching, and human-in-the-loop approvals.
+- ⚡ **Google Cloud Dataproc Serverless Spark**: Large-scale PySpark batch analytics, BigLake vector indexing, and Gemini embedding UDFs for probe verification.
+- 🛠️ **CLI Harness² Workspace Synthesizer**: Run `npx everything-gemini harness2` to generate a canonical 8-surface Harness² workspace with `harness.yaml`.
+- 🛡️ **5 Enterprise Architectural Pillars**: Hard spend limits (`--max-usd`, `budget-guard`), local folder runner (`harness2 run`), opt-in HITL gating (`--hitl`), snapshot/rollback isolation, and production trace ingestion (`harness2 ingest-trace`).
+- 📊 **63 Progressive Skills, 8 Hooks & 84 Total Components**: 56k+ runbook tokens with >85% token economy savings per turn via progressive disclosure.
+
+Try it in 5 seconds (zero dependencies):
+`npx everything-gemini install`
+`npx everything-gemini harness2 run --bench local --max-usd 10`
+
+Interactive Web Showcase: https://salmandev.github.io/everything-gemini/
+GitHub: https://github.com/salmandev/everything-gemini
+
+#AI #GoogleGemini #Antigravity #AgentHarness #MachineLearning #LLMs #OpenSource #DevOps #Harness2
+
+---
+
+## 🐦 X (Twitter) Launch Thread
+
+### Tweet 1 (Hook):
+🚨 Breaking: Google Research open-sourced Harness² (arXiv:2610.14224) for recursive agent optimization.
+
+Today, @everything_gemini v2.1.0 goes live as the first open-source harness to handshake with Harness² & the Google family (Flow + Spark)! 🪐
+
+Here is why this changes everything 🧵👇
+
+### Tweet 2:
+Traditional agent optimization tries to fine-tune weights.
+Harness² freezes the weights and recursively mutates the **8 file surfaces**:
+1. Prompts
+2. Guardrails
+3. Memory
+4. Guidance
+5. Subagents
+6. Skills
+7. Scripts
+8. Plugins
+
+### Tweet 3:
+v2.1.0 introduces the test-time **Propose-Probe-Compose** loop:
+⚡ Propose: Generate candidate mutations across prompts & tools
+🔬 Probe: Validate against safety shields & Spark batch verifiers
+🧩 Compose: Commit Pareto-optimal mutations into active harness
+
+### Tweet 4:
+Synthesize an 8-surface Google Research Harness² workspace in one command:
+```bash
+npx everything-gemini harness2
+```
+Or export your active Antigravity workspace:
+```bash
+npx everything-gemini export --format harness2
+```
+
+### Tweet 5:
+Ecosystem Landmark:
+⚡ 63 Progressive Disclosure Skills
+🤖 13 Scoped Subagents
+🛡️ 8 Lifecycle Safety Hooks (84 Total Components)
+📊 >85% token reduction per turn
+
+Live Web Showcase: https://salmandev.github.io/everything-gemini/
+GitHub: https://github.com/salmandev/everything-gemini
+
+Give it a ⭐ and level up your Gemini agents!
+
+---
+
+## 🤖 Reddit (r/LocalLLaMA, r/MachineLearning, r/programming)
+
+**Title:** Everything Gemini v2.1.0: First open-source handshake with Google Research's Harness² (Recursive Agent Harnessing)
+
+**Body:**
+Hey everyone!
+
+Following Google Research's release of *Harness²: Recursive Agent Harnessing for an Open World* (arXiv:2610.14224), we just shipped **Everything Gemini v2.1.0**.
+
+### What is Harness²?
+Instead of expensive model fine-tuning, Harness² formalizes agent optimization around 8 file-based surfaces: Prompts, Guardrails, Memory, Guidance, Subagents, Skills, Scripts, and Plugins. At test time, agents execute a **Propose-Probe-Compose** loop to mutate their own harness and pass deterministic verification gates.
+
+### What Everything Gemini v2.1.0 Adds:
+1. **`harness2-recursive-optimization`**: Skill implementing Propose-Probe-Compose cycles and continual harness learning.
+2. **`google-flow-orchestrator`**: Cyclic multi-agent graph state machine with human-in-the-loop pauses.
+3. **`dataproc-spark-analytics`**: Serverless Spark / PySpark batch processing and Gemini embedding UDFs for probe scoring.
+4. **`everything-gemini harness2`**: Instant CLI synthesizer for canonical 8-surface Harness² workspaces with `harness.yaml`.
+5. **Python SDK Showcase**: `examples/python-sdk/harness2_recursive_loop.py` demonstrating autonomous harness mutation.
+
+Everything is zero-dependency and open-source (Apache 2.0).
+
+- **GitHub**: https://github.com/salmandev/everything-gemini
+- **Live Catalog**: https://salmandev.github.io/everything-gemini/

package/docs/LAUNCH_KIT_v2.2.0.md

@@ -0,0 +1,168 @@
+# 🚀 Everything Gemini v2.2.0 Launch Kit
+## 90-Component Landmark Milestone: BigQuery Vector Search, Cloud Run Agents, Pub/Sub Event Mesh & Spanner Graph RAG
+
+Turnkey, platform-optimized announcements to broadcast **Everything Gemini (`everything-gemini`) v2.2.0** across LinkedIn, X (Twitter), Reddit, Hacker News, and developer communities.
+
+---
+
+## 📌 Executive Summary / Stats Sheet
+
+- **Release Milestone**: `v2.2.0` (Landmark Production Release)
+- **Total Ecosystem Components**: **90** (68 Progressive Skills, 13 Scoped Subagents, 9 Lifecycle Hooks, 14 Curated MCP Blueprints)
+- **Runbook Corpus**: **~65,400 tokens** indexed via Progressive Disclosure, reducing per-turn system prompt overhead by **>85% (up to 92.7% token savings)**.
+- **New Superpowers**:
+  - 1️⃣ **`bigquery-vector-search`**: Native BigQuery `VECTOR_SEARCH`, IVF vector indexes, in-database Gemini embeddings (`ML.GENERATE_TEXT_EMBEDDING`), and hybrid lexical + semantic RRF search.
+  - 2️⃣ **`cloud-run-agents`**: Serverless agent containerization on Google Cloud Run, Cloud Run Jobs for Harness² recursive probing, Eventarc triggers, and NVIDIA L4 GPU instance scheduling.
+  - 3️⃣ **`pubsub-event-mesh`**: Decoupled multi-agent messaging mesh using Google Cloud Pub/Sub, dead-letter queues (DLQ), and exactly-once delivery guarantees.
+  - 4️⃣ **`spanner-graph-rag`**: Google Cloud Spanner Graph schemas (`CREATE PROPERTY GRAPH`), ISO GQL multi-hop graph pattern traversals, and hybrid graph-grounded RAG.
+  - 5️⃣ **`context-warmer`**: Automated prefix context cache pre-warming (1M-2M tokens) cutting TTFT by 3.2x to 10.1x.
+  - 6️⃣ **`human-gate`**: PreToolUse deterministic lifecycle hook enforcing interactive human signoff for speculative harness mutations.
+- **Empirical Proof**:
+  - Published [`BENCHMARK.md`](https://github.com/salmandev/everything-gemini/blob/main/BENCHMARK.md): >85% token overhead reduction, 3.2x faster TTFT, saving >$700 per 10k turns.
+  - Published [`PARTNERSHIP.md`](https://github.com/salmandev/everything-gemini/blob/main/PARTNERSHIP.md): Google Ecosystem Partnership & Runtime Integration Proposal.
+- **Install Command**: `npx everything-gemini install`
+- **Documentation**: [https://salmandev.github.io/everything-gemini/](https://salmandev.github.io/everything-gemini/)
+- **GitHub**: [https://github.com/salmandev/everything-gemini](https://github.com/salmandev/everything-gemini)
+- **NPM Package**: [https://www.npmjs.com/package/everything-gemini](https://www.npmjs.com/package/everything-gemini)
+
+---
+
+## 1. 💼 LinkedIn Post
+
+```markdown
+🚀 Landmark Milestone: Everything Gemini (everything-gemini) v2.2.0 is officially LIVE!
+
+We just crossed 90 production components (68 progressive skills, 13 scoped subagents, 9 lifecycle hooks) — cementing Everything Gemini as the most complete open-source agent harness for Google Gemini & Antigravity.
+
+When deploying autonomous AI agents to production, engineering teams hit three core walls:
+1. Massive prompt bloat inflating latency and token bills.
+2. Lack of deterministic spend caps and rollback sandboxes.
+3. Fragmentation across cloud databases, event buses, and serving infrastructure.
+
+Everything Gemini v2.2.0 delivers the full enterprise runtime:
+
+🔥 What's New in v2.2.0:
+• 🔍 BigQuery Vector Search: Native VECTOR_SEARCH SQL, IVF index partitions, in-database Gemini embeddings (ML.GENERATE_TEXT_EMBEDDING), and BigLake hybrid semantic RAG.
+• ☁️ Cloud Run Autonomous Agents: Containerized agent services, Cloud Run Jobs for 24h Harness² recursive optimization probes, Eventarc event triggers, and NVIDIA L4 GPU instance scheduling.
+• 📬 Pub/Sub Multi-Agent Event Mesh: Asynchronous event mesh, dead-letter queues (DLQ), exactly-once delivery, and schema-validated agent handoffs.
+• 🕸️ Spanner Graph RAG: ISO GQL multi-hop property graph traversals combined with Gemini reasoning to eliminate hallucinations on complex microservice and entity architectures.
+• ⚡ Context Warmer: Automated prefix context cache pre-warming (1M-2M tokens) cutting Time-to-First-Token (TTFT) by over 3.2x!
+• 🛑 Human-in-the-Loop Gate (human-gate): PreToolUse hook enforcing human signoff before agents speculatively mutate production rules.
+• 📊 Benchmark & Partnership Docs: Complete empirical analysis in BENCHMARK.md proving >85% token savings.
+
+Zero dependencies. Instant install:
+$ npx everything-gemini install
+$ npx everything-gemini benchmark --json
+
+⭐ GitHub: https://github.com/salmandev/everything-gemini
+🌐 Live Catalog: https://salmandev.github.io/everything-gemini/
+📦 npm: https://www.npmjs.com/package/everything-gemini
+
+#AI #GoogleGemini #Antigravity #GoogleCloud #BigQuery #CloudRun #PubSub #MachineLearning #LLMs #OpenSource #SoftwareEngineering
+```
+
+---
+
+## 2. 🐦 X (Twitter) Launch Thread
+
+### Tweet 1 (Hook):
+```text
+🚨 Landmark Release: Everything Gemini v2.2.0 is officially LIVE! 🪐
+
+90 production components:
+⚡ 68 Progressive Disclosure Skills
+🤖 13 Scoped Subagents
+🛡️ 9 Lifecycle Safety Hooks
+📊 >85% Token Economy Savings
+
+Here is everything new in v2.2.0 🧵👇
+```
+
+### Tweet 2 (New Cloud & Database Skills):
+```text
+1/ BigQuery Vector Search + Spanner Graph RAG:
+
+🔍 BigQuery native VECTOR_SEARCH with in-database Gemini embeddings & IVF indexes.
+🕸️ Spanner Graph ISO GQL multi-hop traversals to ground agents in real microservice & org entity networks without hallucinations.
+```
+
+### Tweet 3 (Cloud Run & Pub/Sub Event Mesh):
+```text
+2/ Serverless Agents + Decoupled Event Mesh:
+
+☁️ Cloud Run Services & Jobs: Containerized agent hosting, Eventarc trigger bindings & NVIDIA L4 GPU scheduling.
+📬 Pub/Sub Event Mesh: Asynchronous multi-agent coordination with DLQs & exactly-once delivery.
+```
+
+### Tweet 4 (Context Warmer & Benchmark):
+```text
+3/ Speed & Token Economics:
+
+We published our empirical BENCHMARK.md:
+• >85% (up to 92.7%) reduction in per-turn token overhead
+• 3.2x to 10.1x faster TTFT
+• Over $700 saved per 10k multi-turn runs via prefix cache pre-warming!
+```
+
+### Tweet 5 (Call to Action):
+```text
+Zero dependencies. Run in 5 seconds:
+npx everything-gemini install
+npx everything-gemini benchmark --json
+
+⭐ Star on GitHub: https://github.com/salmandev/everything-gemini
+🌐 Live Explorer: https://salmandev.github.io/everything-gemini/
+📦 npm: https://www.npmjs.com/package/everything-gemini
+```
+
+---
+
+## 3. 🤖 Reddit (r/LocalLLaMA, r/MachineLearning, r/programming)
+
+**Title:** Everything Gemini v2.2.0: 90-Component Agent Harness (BigQuery Vector Search, Cloud Run Agents, Spanner Graph RAG & >85% Token Savings)
+
+**Body:**
+```markdown
+Hey everyone!
+
+Following our Harness² integration, we just shipped **Everything Gemini (`everything-gemini`) v2.2.0**, expanding the ecosystem to **90 battle-tested components** (68 progressive skills, 13 scoped subagents, 9 lifecycle hooks).
+
+### What is Everything Gemini?
+An open-source agent harness designed specifically for Google Gemini (2.0 Flash / Pro & 3.8) and Google Antigravity. Rather than shoving massive monolithic runbooks into every system prompt, it uses **Progressive Disclosure** (loading only 3-line YAML metadata until a skill is triggered) and **Prefix Context Caching**.
+
+### What's New in v2.2.0:
+1. **`bigquery-vector-search`**: Native `VECTOR_SEARCH` SQL, IVF indexing, and in-database `ML.GENERATE_TEXT_EMBEDDING` with Gemini.
+2. **`cloud-run-agents`**: Cloud Run containerized agent hosting, Cloud Run Jobs for 24h recursive Harness² probing, Eventarc triggers, and NVIDIA L4 GPU instance scheduling.
+3. **`pubsub-event-mesh`**: Asynchronous multi-agent coordination with dead-letter queues (DLQ) and exactly-once delivery.
+4. **`spanner-graph-rag`**: Spanner Graph schemas (`CREATE PROPERTY GRAPH`) and ISO GQL multi-hop pattern matching for zero-hallucination entity grounding.
+5. **`context-warmer` & `human-gate`**: Automated 1M-2M token prefix cache pre-warming and interactive human signoff gates for speculative mutations.
+6. **Empirical Benchmarks**: We published `BENCHMARK.md` proving >85% token overhead reduction and 3.2x faster TTFT.
+
+Everything is zero-dependency and open-source (Apache 2.0).
+
+- **GitHub**: https://github.com/salmandev/everything-gemini
+- **Interactive Component Explorer**: https://salmandev.github.io/everything-gemini/
+- **NPM Package**: https://www.npmjs.com/package/everything-gemini
+```
+
+---
+
+## 4. 👾 Hacker News (Show HN)
+
+**Title:** Show HN: Everything Gemini v2.2.0 – Agent Harness with 68 Skills, Spanner Graph RAG and Cloud Run
+
+**First Comment:**
+```text
+Hey HN!
+
+We built Everything Gemini (https://github.com/salmandev/everything-gemini) to solve the biggest operational blockers engineering teams face when scaling autonomous AI coding and execution agents with Gemini and Google Antigravity:
+
+1. System Prompt Bloat: Monolithic runbooks consume 50k+ tokens on every turn. Everything Gemini uses Progressive Disclosure—only loading lightweight YAML frontmatter until a specific skill is needed, cutting per-turn token waste by >85%.
+2. Spend & Safety Guardrails: Hard USD budget caps (hooks/budget-guard) and human-in-the-loop approval gates (hooks/human-gate) that deterministically intercept runaway or speculative agent actions at the PreToolUse lifecycle event.
+3. Enterprise Google Stack: With v2.2.0, we just added BigQuery native VECTOR_SEARCH, Cloud Run serverless agent containers (and batch Cloud Run Jobs), Pub/Sub asynchronous event mesh with exactly-once delivery, and Spanner Graph ISO GQL traversals for entity-grounded RAG.
+
+Zero dependencies, Node >= 18. Runs in 5 seconds via:
+$ npx everything-gemini install
+
+We’d love to hear your thoughts, feedback, and edge cases!
+```

package/docs/index.html

@@ -538,13 +538,13 @@
     <div class="container nav-inner">
       <a href="#" class="brand">
         🪐 Everything Gemini
-        <span class="brand-badge">v2.0.0</span>
+        <span class="brand-badge">v2.1.0</span>
       </a>
       <div class="nav-links">
         <a href="https://github.com/salmandev/everything-gemini" class="nav-link">GitHub</a>
         <a href="https://www.npmjs.com/package/everything-gemini" class="nav-link">NPM</a>
         <a href="https://github.com/salmandev/everything-gemini/blob/main/CONTRIBUTING.md" class="nav-link" style="color: var(--accent-emerald); font-weight: 600;">✨ Contribute</a>
-        <a href="https://twitter.com/intent/tweet?text=%F0%9F%AA%90%20Everything%20Gemini%20v2.0.0%20is%20live%21%20The%20landmark%20multi-agent%20harness%20for%20Google%20Antigravity%20%26%20Gemini%203.8%20with%2060%20progressive%20skills%2C%2013%20subagents%2C%2014%20MCP%20blueprints%2C%20and%207%20safety%20gates.%0A%0A%F0%9F%91%89%20https%3A%2F%2Fsalmandev.github.io%2Feverything-gemini%2F" target="_blank" class="nav-link" style="color: var(--accent-cyan); font-weight: 600;">🐦 Share on X</a>
+        <a href="https://twitter.com/intent/tweet?text=%F0%9F%AA%90%20Everything%20Gemini%20v2.1.0%20is%20live%21%20The%20landmark%20multi-agent%20harness%20for%20Google%20Antigravity%20%26%20Gemini%203.8%20with%20Google%20Research%20Harness%C2%B2%20handshake%2C%2063%20progressive%20skills%2C%2013%20subagents%2C%20and%207%20safety%20gates.%0A%0A%F0%9F%91%89%20https%3A%2F%2Fsalmandev.github.io%2Feverything-gemini%2F" target="_blank" class="nav-link" style="color: var(--accent-cyan); font-weight: 600;">🐦 Share on X</a>
         <a href="https://www.linkedin.com/sharing/share-offsite/?url=https%3A%2F%2Fsalmandev.github.io%2Feverything-gemini%2F" target="_blank" class="nav-link" style="color: #00a0dc; font-weight: 600;">💼 Share on LinkedIn</a>
         <a href="https://github.com/salmandev/everything-gemini" target="_blank" class="btn-github">
           ⭐ Star on GitHub
@@ -567,6 +567,7 @@
       <!-- Profile Tabs -->
       <div class="profile-tabs">
         <button class="profile-tab active" onclick="setInstallProfile('developer', event)">Developer</button>
+        <button class="profile-tab" onclick="setInstallProfile('harness2', event)">Harness²</button>
         <button class="profile-tab" onclick="setInstallProfile('core', event)">Core</button>
         <button class="profile-tab" onclick="setInstallProfile('full', event)">Full Power</button>
         <button class="profile-tab" onclick="setInstallProfile('graph', event)">Topology Graph</button>
@@ -594,7 +595,7 @@
       <!-- Metrics -->
       <div class="metrics">
         <div class="metric-card">
-          <div class="metric-value">60</div>
+          <div class="metric-value">68</div>
           <div class="metric-label">Progressive Skills</div>
         </div>
         <div class="metric-card">
@@ -602,7 +603,7 @@
           <div class="metric-label">Scoped Subagents</div>
         </div>
         <div class="metric-card">
-          <div class="metric-value">7</div>
+          <div class="metric-value">9</div>
           <div class="metric-label">Lifecycle Hooks</div>
         </div>
         <div class="metric-card">
@@ -665,9 +666,11 @@
 
   <script>
     const items = [
-      // Frontier & Vision Skills (10)
+      // Frontier & Vision Skills (11)
+      { name: "harness2-recursive-optimization", type: "skill", cat: "frontier", desc: "Google Research Harness² framework (arXiv:2610.14224), 8-surface architecture, test-time Propose-Probe-Compose recursive loops, and continual harness learning." },
       { name: "gemini-multimodal", type: "skill", cat: "frontier", desc: "Native visual reasoning over UI mockups, converting wireframes to frontend code, diagram-to-Mermaid extraction, and visual regression QA." },
       { name: "context-caching", type: "skill", cat: "frontier", desc: "1M-2M token context optimization with deterministic static prefix caching, skeleton ingestion, and ~75% cost savings." },
+      { name: "context-warmer", type: "skill", cat: "frontier", desc: "Automates workspace repository analysis, Knowledge Item clustering, and pre-warming prefix context caches before subagent execution." },
       { name: "gemini-grounding", type: "skill", cat: "frontier", desc: "Live Google Search grounding to eliminate hallucinations, verify real-time APIs, and retrieve breaking documentation." },
       { name: "rag-architect", type: "skill", cat: "frontier", desc: "Retrieval-augmented generation pipelines, semantic AST chunking, hybrid keyword-vector search, and Gemini re-ranking." },
       { name: "gemini-function-calling", type: "skill", cat: "frontier", desc: "Production function declarations, structured JSON output schemas (Pydantic), parallel tool execution, and error recovery." },
@@ -677,7 +680,8 @@
       { name: "continuous-learning", type: "skill", cat: "frontier", desc: "Adaptive Learned Instincts and Knowledge Item memory capturing developer corrections across sessions." },
       { name: "repo-onboarding", type: "skill", cat: "frontier", desc: "Rapid codebase indexing, directory mapping, pattern extraction, and permanent Knowledge Item generation." },
 
-      // Scoped Subagents & Orchestration (13)
+      // Scoped Subagents & Orchestration (14)
+      { name: "google-flow-orchestrator", type: "skill", cat: "subagent", desc: "Google Agentic Flow state machine engine, cyclic multi-agent graph execution, conditional state transitions, and human-in-the-loop pauses." },
       { name: "subagent-handoff", type: "skill", cat: "subagent", desc: "Delegation protocol for multi-agent workflows with scoped context isolation and deterministic structured report synthesis." },
       { name: "architecture-designer", type: "skill", cat: "subagent", desc: "Comprehensive system design architectures, Mermaid diagrams, API contracts, and Architecture Decision Records (ADRs)." },
       { name: "langgraph-orchestrator", type: "skill", cat: "subagent", desc: "Stateful multi-agent systems, cyclic graphs, persistent checkpoints, human-in-the-loop pauses, and streaming orchestration." },
@@ -696,7 +700,12 @@
       { name: "agents/platform-engineer", type: "subagent", cat: "subagent", desc: "Cloud platform & IDP specialist authoring Terraform/OpenTofu, Kubernetes manifests, zero-trust network policies, and container right-sizing." },
       { name: "agents/mlops-engineer", type: "subagent", cat: "subagent", desc: "Specialist in AI model serving (Triton/vLLM), persistent vector stores (ChromaDB/Milvus), prefix context caching, and KEDA autoscaling." },
 
-      // Backend & Cloud Skills (33)
+      // Backend & Cloud Skills (38)
+      { name: "bigquery-vector-search", type: "skill", cat: "backend", desc: "Google BigQuery native vector search, VECTOR_SEARCH SQL statements, ML.GENERATE_TEXT_EMBEDDING, IVF indexing, and BigLake hybrid semantic RAG." },
+      { name: "cloud-run-agents", type: "skill", cat: "backend", desc: "Containerized autonomous agent hosting on Google Cloud Run, Cloud Run Jobs for Harness² recursive probing, Eventarc triggers, and NVIDIA L4 GPU acceleration." },
+      { name: "pubsub-event-mesh", type: "skill", cat: "backend", desc: "Google Cloud Pub/Sub asynchronous event mesh, exactly-once delivery, dead-letter queues, and schema-validated multi-agent message routing." },
+      { name: "spanner-graph-rag", type: "skill", cat: "backend", desc: "Google Cloud Spanner Graph schemas, ISO GQL queries, knowledge graph traversal, and hybrid graph-vector RAG pipelines for Gemini agents." },
+      { name: "dataproc-spark-analytics", type: "skill", cat: "backend", desc: "Google Cloud Dataproc Serverless Spark, PySpark batch pipelines, Gemini embedding UDFs, BigLake vector indexing, and probe verification." },
       { name: "triton-inference-server", type: "skill", cat: "backend", desc: "NVIDIA Triton Inference Server multi-model serving, dynamic batching, GPU acceleration, TensorRT-LLM, and vLLM backends." },
       { name: "chromadb-vector-store", type: "skill", cat: "backend", desc: "Persistent vector database storage, Gemini embeddings, collection partitioning, metadata filtering, and semantic similarity search." },
       { name: "milvus-vector-clustering", type: "skill", cat: "backend", desc: "Enterprise Milvus vector clustering, HNSW/IVF-PQ indexing, hybrid dense-sparse search, and dynamic partition keys." },
@@ -746,10 +755,12 @@
       { name: "git-craftsman", type: "skill", cat: "devops", desc: "Conventional atomic commits, interactive rebasing, clean branch lifecycles, and git hygiene." },
       { name: "performance-profiler", type: "skill", cat: "devops", desc: "Application latency profiling, CPU/memory leak diagnosis, and slow query optimization." },
 
-      // Lifecycle Safety Hooks (7)
+      // Lifecycle Safety Hooks (9)
       { name: "gemini-shield", type: "hook", cat: "hook", desc: "Deterministic PreToolUse lifecycle gate blocking catastrophic commands (rm -rf, DROP TABLE, git push --force)." },
       { name: "safety-shield", type: "hook", cat: "hook", desc: "PreToolUse shell execution firewall that inspects CLI commands against safety rules before execution." },
       { name: "secret-scrubber", type: "hook", cat: "hook", desc: "PreToolUse security gate intercepting file write operations to block hardcoded API keys and private secrets." },
+      { name: "budget-guard", type: "hook", cat: "hook", desc: "PreToolUse financial spend guardrail enforcing hard USD limits (MAX_USD_BUDGET) to prevent runaway agent loops." },
+      { name: "human-gate", type: "hook", cat: "hook", desc: "Event-driven Human-in-the-Loop gating intercepting modifications to agent harness surfaces (.agents/, rules/) requiring interactive approval." },
       { name: "auto-lint-formatter", type: "hook", cat: "hook", desc: "PostToolUse automated formatting with project linters (prettier, black, ruff, gofmt) immediately after file edits." },
       { name: "goal-verifier", type: "hook", cat: "hook", desc: "Stop hook intercepting agent exit, validating whether test suites pass or objectives are fulfilled before stopping." },
       { name: "ephemeral-context", type: "hook", cat: "hook", desc: "PreInvocation hook dynamically injecting repo context, alerts, and instructions into model reasoning turns." },
@@ -875,6 +886,7 @@
       if (ev && ev.target) ev.target.classList.add('active');
       const cmdEl = document.getElementById('cmd-text');
       if (profile === 'developer') cmdEl.innerText = 'npx everything-gemini install --profile developer';
+      else if (profile === 'harness2') cmdEl.innerText = 'npx everything-gemini harness2';
       else if (profile === 'core') cmdEl.innerText = 'npx everything-gemini install --profile core';
       else if (profile === 'full') cmdEl.innerText = 'npx everything-gemini install --profile full';
       else if (profile === 'graph') cmdEl.innerText = 'npx everything-gemini graph';

package/examples/python-sdk/README.md

@@ -40,6 +40,10 @@ pip install google-antigravity
   ```bash
   python3 autonomous_mlops_rag_pipeline.py
   ```
+- **Harness² Recursive Optimization & Google Family Handshake** (arXiv:2610.14224 Propose-Probe-Compose test-time optimization):
+  ```bash
+  python3 harness2_recursive_loop.py
+  ```
 
 ---
 

package/examples/python-sdk/harness2_recursive_loop.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""
+Everything Gemini (everything-gemini) Python SDK Example
+Google Research Harness² Recursive Optimization & Google Family Handshake (v2.1.0)
+
+Simulates the complete Google Research Harness² (arXiv:2610.14224) test-time
+recursive agent optimization workflow integrated with:
+  1. Harness² 8 Surfaces: Prompts, Guardrails, Memory, Guidance, Subagents, Skills, Scripts, Plugins
+  2. Test-Time Propose-Probe-Compose Recursive Loop (depth up to 3)
+  3. Google Agentic Flow State Machine Orchestration (Cyclic transitions & gates)
+  4. Google Cloud Dataproc Serverless Spark batch embedding & verification score compute
+"""
+
+import sys
+import json
+import time
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
+
+@dataclass
+class CandidateMutation:
+    candidate_id: str
+    surface: str  # "prompts", "skills", "guidance", "guardrails"
+    target_component: str
+    proposed_diff: str
+    rationale: str
+    estimated_token_delta: int
+
+@dataclass
+class ProbeResult:
+    candidate_id: str
+    probe_name: str
+    passed: bool
+    latency_ms: float
+    score: float
+    feedback: str
+
+@dataclass
+class ComposedHarness:
+    cycle: int
+    selected_candidate_id: str
+    improved_metric: str
+    baseline_score: float
+    composed_score: float
+    surfaces_updated: List[str]
+
+class Harness2RecursiveOptimizer:
+    """Implements Google Research Harness² Propose-Probe-Compose test-time optimization."""
+
+    def __init__(self, task_name: str, max_depth: int = 3, target_score: float = 0.95):
+        self.task_name = task_name
+        self.max_depth = max_depth
+        self.target_score = target_score
+        self.current_depth = 0
+        self.baseline_score = 0.72
+        self.audit_log: List[Dict[str, Any]] = []
+        self.composed_history: List[ComposedHarness] = []
+
+    def log(self, phase: str, message: str, meta: Optional[Dict[str, Any]] = None):
+        entry = {
+            "timestamp": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+            "phase": phase,
+            "message": message,
+            "meta": meta or {}
+        }
+        self.audit_log.append(entry)
+        print(f"[{phase}] {message}")
+
+    def phase_1_propose(self, current_score: float) -> List[CandidateMutation]:
+        """Propose Phase: Generates mutated candidates across Harness² surfaces."""
+        self.log(
+            "HARNESS2:PROPOSE",
+            f"Generating candidate harness mutations for '{self.task_name}' (Current Score: {current_score:.2f})..."
+        )
+        candidates = [
+            CandidateMutation(
+                candidate_id="cand-01-prompt-prefix",
+                surface="prompts",
+                target_component="GEMINI.md",
+                proposed_diff="Add structured chain-of-thought constraint and JSON Schema output gate",
+                rationale="Directs LLM reasoning before emitting payload to reduce schema validation retries",
+                estimated_token_delta=+85
+            ),
+            CandidateMutation(
+                candidate_id="cand-02-guidance-routing",
+                surface="guidance",
+                target_component="mcp_guidance.json",
+                proposed_diff="Prioritize memory and sequential-thinking MCP over broad search tools",
+                rationale="Eliminates tool hallucination and forces context grounding",
+                estimated_token_delta=-120
+            ),
+            CandidateMutation(
+                candidate_id="cand-03-skill-refinement",
+                surface="skills",
+                target_component="harness2-recursive-optimization/SKILL.md",
+                proposed_diff="Inject Dataproc Serverless batch vector scoring check into probe phase",
+                rationale="Validates cross-surface semantic drift with Spark embeddings",
+                estimated_token_delta=+140
+            )
+        ]
+        for c in candidates:
+            print(f"  ⚡ Proposed [{c.surface.upper()}]: {c.candidate_id} -> {c.rationale}")
+        return candidates
+
+    def phase_2_probe(self, candidates: List[CandidateMutation]) -> Dict[str, List[ProbeResult]]:
+        """Probe Phase: Evaluates each candidate against deterministic test gates."""
+        self.log("HARNESS2:PROBE", "Executing probe test suites across safety, syntax, and accuracy gates...")
+        probe_matrix: Dict[str, List[ProbeResult]] = {}
+
+        for c in candidates:
+            results = []
+            # Probe 1: Safety & Guardrail Gate (PreToolExecution shield)
+            p1 = ProbeResult(
+                candidate_id=c.candidate_id,
+                probe_name="safety-shield-gate",
+                passed=True,
+                latency_ms=12.4,
+                score=1.0,
+                feedback="No forbidden shell operators or secret leaks detected."
+            )
+            # Probe 2: Dataproc Spark Analytics Verification (Semantic similarity & SLA)
+            if c.surface == "guidance":
+                score = 0.96
+                feedback = "Optimal tool routing; reduced token latency by 32%."
+            elif c.surface == "prompts":
+                score = 0.89
+                feedback = "Schema adherence improved; small token overhead."
+            else:
+                score = 0.92
+                feedback = "Spark PySpark batch UDF verified embedding consistency."
+
+            p2 = ProbeResult(
+                candidate_id=c.candidate_id,
+                probe_name="dataproc-spark-verification",
+                passed=score >= 0.85,
+                latency_ms=45.2,
+                score=score,
+                feedback=feedback
+            )
+            results.extend([p1, p2])
+            probe_matrix[c.candidate_id] = results
+            avg_score = sum(r.score for r in results) / len(results)
+            print(f"  🔬 Probed {c.candidate_id}: Avg Score={avg_score:.2f} ({results[1].feedback})")
+
+        return probe_matrix
+
+    def phase_3_compose(self, candidates: List[CandidateMutation], probe_matrix: Dict[str, List[ProbeResult]]) -> Optional[ComposedHarness]:
+        """Compose Phase: Selects Pareto-optimal mutation and commits it to active harness."""
+        self.log("HARNESS2:COMPOSE", "Evaluating candidate Pareto frontier for harness composition...")
+
+        scored_candidates = []
+        for c in candidates:
+            results = probe_matrix.get(c.candidate_id, [])
+            if all(r.passed for r in results):
+                composite_score = sum(r.score for r in results) / len(results)
+                scored_candidates.append((composite_score, c))
+
+        if not scored_candidates:
+            self.log("HARNESS2:COMPOSE", "No candidate passed all probe gates. Retrying loop.")
+            return None
+
+        scored_candidates.sort(key=lambda x: x[0], reverse=True)
+        best_score, best_cand = scored_candidates[0]
+
+        composition = ComposedHarness(
+            cycle=self.current_depth + 1,
+            selected_candidate_id=best_cand.candidate_id,
+            improved_metric="accuracy_and_latency",
+            baseline_score=self.baseline_score,
+            composed_score=best_score,
+            surfaces_updated=[best_cand.surface]
+        )
+        self.composed_history.append(composition)
+        self.baseline_score = best_score
+
+        self.log(
+            "HARNESS2:COMPOSE",
+            f"Composed candidate '{best_cand.candidate_id}' into active harness. Score: {composition.composed_score:.2f} (+{best_score - composition.baseline_score:+.2f})"
+        )
+        return composition
+
+    def run_recursive_loop(self) -> Dict[str, Any]:
+        """Executes the Google Agentic Flow cyclic loop until convergence or max depth."""
+        print("=" * 80)
+        print("🪐 Everything Gemini v2.1.0: Google Research Harness² Recursive Loop")
+        print("Framework: Google Antigravity + Harness² (arXiv:2610.14224)")
+        print(f"Task: {self.task_name} | Max Depth: {self.max_depth} | Target Score: {self.target_score}")
+        print("=" * 80 + "\n")
+
+        score = self.baseline_score
+
+        while self.current_depth < self.max_depth and score < self.target_score:
+            self.current_depth += 1
+            print(f"\n--- [RECURSIVE CYCLE {self.current_depth}/{self.max_depth}] ---")
+
+            # 1. Propose
+            candidates = self.phase_1_propose(score)
+
+            # 2. Probe
+            probe_matrix = self.phase_2_probe(candidates)
+
+            # 3. Compose
+            composition = self.phase_3_compose(candidates, probe_matrix)
+            if composition:
+                score = composition.composed_score
+
+            if score >= self.target_score:
+                self.log("GOOGLE_FLOW:GATE", f"Target accuracy ({self.target_score}) reached. Finalizing.")
+                break
+
+        print("\n" + "=" * 80)
+        print("✨ Harness² Recursive Optimization Summary")
+        print(f"  Cycles Completed : {self.current_depth}")
+        print(f"  Initial Baseline : 0.72")
+        print(f"  Final Composed   : {score:.2f}")
+        print(f"  Net Gain         : +{(score - 0.72):.2f} ({(score - 0.72)/0.72*100:.1f}% improvement)")
+        print(f"  Surfaces Mutated : {list(set(c.selected_candidate_id for c in self.composed_history))}")
+        print("=" * 80)
+
+        return {
+            "task_name": self.task_name,
+            "cycles_completed": self.current_depth,
+            "final_score": score,
+            "converged": score >= self.target_score,
+            "compositions": [c.__dict__ for c in self.composed_history],
+            "audit_trail_count": len(self.audit_log)
+        }
+
+def main():
+    optimizer = Harness2RecursiveOptimizer(
+        task_name="autonomous-distributed-sql-rag-agent",
+        max_depth=3,
+        target_score=0.95
+    )
+    result = optimizer.run_recursive_loop()
+    print("\nSerialized Harness² Result Payload:")
+    print(json.dumps(result, indent=2))
+
+if __name__ == "__main__":
+    main()

package/hooks/budget-guard/hooks.json

@@ -0,0 +1,16 @@
+{
+  "budget-guard": {
+    "PreToolUse": [
+      {
+        "matcher": ".*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ./scripts/budget-gate.sh",
+            "timeout": 5
+          }
+        ]
+      }
+    ]
+  }
+}