docs: align repository discovery, keyword indexing, and GitHub search visibility

Optimized Igor for GitHub discovery while maintaining technical credibility:

README.md:
- Enhanced introduction with natural keyword integration
- Added "Technical Domains" section (7 key areas)
- Added "Related Ecosystem Areas" section with disclaimer
- Added architecture overview diagram (ASCII visualization)
- Added "Discovery Keywords" section (structured keyword reference)
- Improved first 25 lines for search indexing
- Natural keyword density without stuffing
- Maintains professional infrastructure tone

docs/KEYWORDS.md (NEW):
- Keyword governance policy
- Core identity keywords (approved terminology)
- Technical stack keywords
- Use case keywords
- Ecosystem alignment keywords
- Disallowed marketing language (explicit list)
- Approved descriptive phrases
- Topic tag policy
- Search query alignment targets
- Tagline consistency rules
- Maintenance procedures
- Philosophy alignment with PROJECT_CONTEXT.md

docs/DISCOVERY_VALIDATION.md (NEW):
- Search query testing framework
- Primary/secondary/tertiary query lists
- Expected ranking guidance
- Validation results tracking
- Topic effectiveness analysis
- Keyword density analysis
- Improvement opportunities
- Monitoring strategy (quarterly validation)

scripts/configure-repo-metadata.sh:
- Expanded topics from 10 to 20 tags
- Added: webassembly, wasm, p2p-runtime, distributed-runtime,
  agent-runtime, survivable-systems, economic-agents,
  execution-runtime, research-infrastructure, distributed-compute
- All topics technically accurate
- Comprehensive coverage of identity, stack, use cases

Go package comments (improved for code search):
- internal/runtime: "survivable autonomous agent execution using WASM"
- internal/migration: "peer-to-peer agent relocation and transfer protocols"
- internal/storage: "checkpoint persistence abstraction for survivable agents"
- Enhances GitHub code search relevance

CONTRIBUTING.md:
- Added "Discoverability and Metadata" section
- Maintain accuracy over SEO guidance
- Reference to KEYWORDS.md governance
- Tagline consistency requirement

Result:
- GitHub search optimized through truthful precision
- 20 repository topics covering all relevant domains
- Natural keyword integration (no stuffing)
- Enhanced code search indexing
- Technical credibility preserved
- Experimental status clear
- Discovery through accuracy, not exaggeration

No runtime behavior changed.
No protocol definitions modified.
No API changes.

Repository now discoverable via: autonomous agents, WASM runtime,
libp2p, distributed systems, runtime economics, survivable software.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: simonovic86

CONTRIBUTING.md

@@ -246,6 +246,22 @@ Performance optimization is secondary to correctness.
 - Mark conversations as resolved when addressed
 - Request re-review after substantial changes
 
+## Discoverability and Metadata
+
+When updating README, repository description, or GitHub metadata:
+
+**Maintain discoverability through technical accuracy:**
+- Use keywords from [docs/KEYWORDS.md](./docs/KEYWORDS.md)
+- Avoid marketing hype or exaggerated claims
+- Preserve experimental status clarity
+- Keep technical credibility as priority over SEO
+
+**Preserve canonical tagline:**
+- "Runtime for survivable autonomous agents"
+- Do not introduce variations without approval
+
+See [docs/KEYWORDS.md](./docs/KEYWORDS.md) for complete keyword governance.
+
 ## Code Style
 
 ### Formatting

README.md

@@ -2,7 +2,7 @@
 
 **Runtime for Survivable Autonomous Agents**
 
-Igor is a decentralized runtime enabling software agents to checkpoint state, migrate between peer nodes, and pay for their own execution. Agents persist independently of any infrastructure provider.
+Igor is a decentralized execution runtime for autonomous software agents. It provides infrastructure primitives enabling agents to checkpoint state, migrate between peer nodes over libp2p, and pay for execution using internal budgets. Agents built on Igor persist independently of any infrastructure provider through WASM sandbox execution, peer-to-peer migration protocols, and runtime economics.
 
 ---
 
@@ -25,11 +25,38 @@ Igor is a decentralized runtime enabling software agents to checkpoint state, mi
 
 ## Why Igor Exists
 
-Autonomous economic software can execute decisions independently but cannot survive infrastructure failure independently.
+Autonomous economic software—including DeFi automation, oracle networks, and AI service agents—can execute decisions independently but cannot survive infrastructure failure autonomously. These distributed systems hold capital, operate continuously, yet remain existentially tied to specific infrastructure.
 
 Trading strategies manage capital without human approval yet stop when servers fail. Oracle participants must maintain continuous uptime yet depend entirely on operators. AI service agents process requests autonomously yet cannot survive the loss of their hosting infrastructure.
 
-Igor provides survival primitives: explicit state checkpointing, peer-to-peer migration, and runtime budget enforcement. Agents persist across infrastructure changes. Infrastructure becomes fungible; agents become persistent.
+Igor provides survivable agent runtime primitives: explicit state checkpointing, peer-to-peer agent migration, and runtime economic metering. Agents persist across distributed infrastructure changes. Infrastructure becomes fungible; agents become persistent.
+
+## Technical Domains
+
+Igor addresses challenges in:
+
+* **Autonomous agent infrastructure** - Runtime for self-managing software entities
+* **Survivable distributed systems** - Execution persistence across infrastructure failure
+* **WASM sandbox runtimes** - Portable deterministic agent execution (wazero)
+* **Peer-to-peer compute mobility** - Agent migration over libp2p networks
+* **Runtime economic accounting** - Budget-based execution metering and enforcement
+* **Self-hosting autonomous software** - Agents that pay for their own compute
+* **Distributed systems research** - Experimental infrastructure for agent survival
+
+## Related Ecosystem Areas
+
+Igor occupies a lower-level runtime infrastructure layer, distinct from agent reasoning or orchestration frameworks.
+
+Relevant adjacent domains:
+* Autonomous AI agent infrastructure and runtimes
+* Distributed compute execution environments
+* WebAssembly execution engines and sandbox runtimes
+* Peer-to-peer service fabrics and distributed protocols
+* DeFi solver network infrastructure
+* Oracle and economic automation service infrastructure
+* Mobile code and process migration research
+
+Igor provides execution survival primitives that these higher-level systems could build upon.
 
 ## Core Guarantees
 
@@ -52,7 +79,32 @@ Igor is **not**:
 
 Igor is a minimal survival runtime. It implements checkpointing, migration, and budget metering. Nothing more.
 
-## Architecture
+## Architecture Overview
+
+```
+┌─────────────────────────────────────────────────┐
+│  Autonomous Agent (WASM)                        │
+│  ┌──────────┐  ┌───────────┐  ┌──────────────┐ │
+│  │  Init    │→ │ Tick Loop │→ │  Checkpoint  │ │
+│  └──────────┘  └─────┬─────┘  └──────┬───────┘ │
+│                      │                │         │
+│                      ↓                ↓         │
+│              ┌──────────────┐  ┌─────────────┐ │
+│              │ Budget       │  │ State       │ │
+│              │ Metering     │  │ Persistence │ │
+│              └──────────────┘  └─────────────┘ │
+└─────────────────────────────────────────────────┘
+                       │
+                       │ Migration (libp2p)
+                       ↓
+┌─────────────────────────────────────────────────┐
+│  Igor Runtime (Node)                            │
+│  ┌──────────┐  ┌───────────┐  ┌──────────────┐ │
+│  │  WASM    │  │ Migration │  │  P2P         │ │
+│  │  Sandbox │  │ Protocol  │  │  Network     │ │
+│  └──────────┘  └───────────┘  └──────────────┘ │
+└─────────────────────────────────────────────────┘
+```
 
 ### Agents
 
@@ -234,6 +286,24 @@ Contributions welcome. Please read:
 
 Security issues: [SECURITY.md](./SECURITY.md)
 
+---
+
+## Discovery Keywords
+
+**Core Identity:**
+Autonomous agent runtime | Survivable distributed systems | WASM agent execution | Peer-to-peer agent migration | Runtime economics | Decentralized execution infrastructure
+
+**Technical Stack:**
+WebAssembly sandbox | wazero runtime | libp2p networking | Go distributed systems | Agent checkpoint persistence | Budget metering infrastructure
+
+**Use Cases:**
+DeFi automation infrastructure | Oracle network runtime | AI agent execution platform | Economic software agents | Autonomous service infrastructure | Distributed compute mobility
+
+**Research Areas:**
+Agent survival primitives | Mobile code execution | Process migration protocols | Runtime accounting systems | Survivable software research | Experimental distributed infrastructure
+
+See [docs/KEYWORDS.md](./docs/KEYWORDS.md) for keyword governance policy.
+
 ## License
 
 MIT

docs/DISCOVERY_VALIDATION.md

@@ -0,0 +1,190 @@
+# Discovery Validation
+
+This document tracks Igor's GitHub search discoverability and validates keyword effectiveness.
+
+## Primary Search Queries
+
+Test Igor's appearance in GitHub repository search for these queries:
+
+### Core Identity Queries
+
+**"autonomous agent runtime"**
+- Expected: Igor appears in top results
+- Relevance: Direct match to core functionality
+- Competition: General agent frameworks, orchestration platforms
+- Igor differentiator: Survival-focused, not reasoning-focused
+
+**"wasm agent runtime"**
+- Expected: Igor appears prominently
+- Relevance: WASM-based agent execution is core architecture
+- Competition: General WASM runtimes, serverless platforms
+- Igor differentiator: Agent-specific, checkpoint/migration support
+
+**"distributed agent infrastructure"**
+- Expected: Igor appears in relevant results
+- Relevance: Distributed systems context
+- Competition: Cloud platforms, orchestration systems
+- Igor differentiator: Decentralized P2P, not centralized platform
+
+**"libp2p runtime"**
+- Expected: Igor appears in libp2p ecosystem searches
+- Relevance: Uses libp2p for P2P migration
+- Competition: IPFS, Filecoin, libp2p demos
+- Igor differentiator: Agent execution runtime, not storage/content
+
+**"survivable software agents"**
+- Expected: Igor should be highly ranked (unique positioning)
+- Relevance: Core thesis - software survival autonomy
+- Competition: Limited (few projects focus on survival primitives)
+- Igor differentiator: Explicit survival as primary feature
+
+### Technical Stack Queries
+
+**"wazero runtime"**
+- Expected: Igor appears among wazero users
+- Relevance: Uses wazero for WASM execution
+- Competition: Other wazero-based projects
+- Igor differentiator: Agent-focused, with migration
+
+**"golang distributed systems"**
+- Expected: Igor appears in Go ecosystem
+- Relevance: Implemented in Go 1.25
+- Competition: Many Go distributed systems
+- Igor differentiator: Agent survival focus
+
+**"libp2p migration"**
+- Expected: Igor appears for libp2p migration use cases
+- Relevance: Implements migration protocol over libp2p
+- Competition: Limited (few implement process migration via libp2p)
+- Igor differentiator: Agent-specific migration with state transfer
+
+### Use Case Queries
+
+**"defi automation infrastructure"**
+- Expected: Igor appears as potential infrastructure layer
+- Relevance: DeFi automation needs persistent execution
+- Competition: Cloud platforms, validator infrastructure
+- Igor differentiator: Decentralized, survivable execution
+
+**"oracle runtime infrastructure"**
+- Expected: Igor appears for oracle execution needs
+- Relevance: Oracle nodes need continuous uptime
+- Competition: Oracle-specific frameworks
+- Igor differentiator: Generic survival runtime, not oracle-specific
+
+**"economic agent runtime"**
+- Expected: Igor should rank well (unique combination)
+- Relevance: Runtime economics as primitive
+- Competition: Limited (few runtimes have built-in economics)
+- Igor differentiator: Budget metering is core feature
+
+## Search Ranking Validation
+
+### Manual Testing
+
+Periodically test these searches on GitHub:
+
+```bash
+# Via web
+https://github.com/search?q=autonomous+agent+runtime&type=repositories
+
+# Via gh CLI
+gh search repos "autonomous agent runtime" --limit 20
+```
+
+Record Igor's position in results.
+
+### Expected Performance
+
+**Strong ranking (top 10):**
+- Survivable software agents
+- WASM agent runtime
+- Agent migration runtime
+
+**Moderate ranking (top 30):**
+- Autonomous agent infrastructure
+- Distributed agent runtime
+- Economic agent systems
+
+**Competitive ranking (appears relevantly):**
+- Distributed systems infrastructure
+- libp2p runtime
+- Go distributed systems
+
+## Validation Results
+
+### Latest Test: 2026-02-12
+
+Query: "autonomous agent runtime"  
+Result: Not yet published to GitHub (local repository)  
+Status: Pending first push
+
+Query: "wasm agent runtime"  
+Result: Pending  
+Status: Repository not yet public
+
+Query: "survivable software"  
+Result: Pending  
+Status: Awaiting public release
+
+**Next validation:** After v0.1.0-genesis release and initial indexing period (24-48 hours).
+
+## Topic Effectiveness
+
+**Current topics:** 20 tags covering:
+- Core identity (autonomous-agents, agent-runtime, survivable-software)
+- Technical stack (wasm, webassembly, wazero, libp2p, go)
+- Architecture (distributed-systems, peer-to-peer, distributed-runtime)
+- Use domains (runtime-economics, economic-agents, research-infrastructure)
+
+**Coverage:** Comprehensive across identity, stack, and use cases
+
+## Keyword Density Analysis
+
+**README.md keyword presence (natural integration):**
+- "autonomous agent" - Multiple instances
+- "WASM" / "WebAssembly" - Multiple instances
+- "libp2p" - Multiple instances
+- "runtime economics" - Multiple instances
+- "checkpoint" / "migration" - High frequency
+- "survivable" / "survival" - High frequency
+
+**Density:** High technical keyword density without stuffing
+
+**Readability:** Maintained (keywords integrated naturally)
+
+## Improvement Opportunities
+
+### After Initial Release
+
+1. **Code examples:** Add more agent examples (increases code search hits)
+2. **Technical blogs:** Write about architecture decisions
+3. **Conference talks:** Present at distributed systems conferences
+4. **Academic citations:** Publish research paper
+5. **Integration examples:** Show Igor used with other systems
+
+### Organic Growth
+
+- GitHub stars increase search ranking
+- Forks signal ecosystem adoption
+- Issues/PRs indicate active development
+- Contributors broaden credibility
+
+## Monitoring Strategy
+
+**Quarterly validation:**
+1. Test primary search queries
+2. Record Igor's ranking
+3. Identify new competing repositories
+4. Adjust keywords if needed (maintain accuracy)
+
+**Annual review:**
+1. Evaluate keyword effectiveness
+2. Update based on ecosystem evolution
+3. Maintain alignment with actual capabilities
+
+## References
+
+- [KEYWORDS.md](./KEYWORDS.md) - Keyword governance policy
+- [PROJECT_CONTEXT.md](../PROJECT_CONTEXT.md) - Core philosophy
+- [README.md](../README.md) - Primary discovery surface