connectonion 0.6.2__py3-none-any.whl → 0.6.4__py3-none-any.whl

connectonion/docs/archive/README.md

@@ -0,0 +1,53 @@
+# Roadmap Documentation Guide
+
+## Document Categories
+
+### 📌 Core Principles
+- **[core-principles-unified.md](./core-principles-unified.md)** - The definitive principles guide (MAIN REFERENCE)
+
+### 🧠 Conceptual Insights
+- **[semantic-revolution.md](./semantic-revolution.md)** - From protocols to understanding
+- **[the-semantic-insight.md](./the-semantic-insight.md)** - Why meaning matters more than form
+- **[attack-defense-insights.md](./attack-defense-insights.md)** - Security through attacker's lens
+
+### 💰 Economic Analysis
+- **[economic-analysis.md](./economic-analysis.md)** - Detailed cost transformations
+- **[mini-whitepaper.md](./mini-whitepaper.md)** - Cost-centric protocol analysis
+
+### 🏗️ Implementation
+- **[technical-architecture.md](./technical-architecture.md)** - How to build it
+- **[migration-strategy.md](./migration-strategy.md)** - Moving from existing systems
+// Removed: Function-as-Agent (deprecated in favor of Share & Find)
+
+### 🛡️ Security
+- **[threat-model.md](./threat-model.md)** - Multi-Agent Collaboration Threat Model
+
+### 📊 Strategy
+- **[business-model.md](./business-model.md)** - Revenue and growth strategy
+- **[mcp-comparison-insights.md](./mcp-comparison-insights.md)** - Why we're different
+
+### 📚 Historical Context
+- **[discussion-journey.md](./discussion-journey.md)** - How these ideas evolved
+
+## Deprecated/To Archive
+
+These files have been consolidated into `core-principles-unified.md`:
+- ~~principles.md~~ (merged)
+- ~~core-principles-extracted.md~~ (merged)
+- ~~simplicity-principles.md~~ (merged)  
+- ~~master-principles.md~~ (merged)
+
+## Reading Order
+
+1. Start with **[core-principles-unified.md](./core-principles-unified.md)**
+2. Understand the paradigm shift in **[semantic-revolution.md](./semantic-revolution.md)**
+3. Grasp the economics in **[mini-whitepaper.md](./mini-whitepaper.md)**
+4. Explore implementation in **[technical-architecture.md](./technical-architecture.md)**
+
+## Key Takeaways
+
+- **Simplicity** is our core design constraint
+- **Behavior** replaces identity
+- **Understanding** replaces protocols
+- **Natural selection** replaces central control
+- **Cost reduction** from O(n²) to O(1) drives adoption

connectonion/docs/archive/archive/consolidation-plan.md

@@ -0,0 +1,72 @@
+# Principle Documents Consolidation Plan
+
+## Current Structure
+
+### Documentation Principles
+- `docs/principles.md` - How to write documentation (KEEP)
+
+### Protocol Principles (TO CONSOLIDATE)
+- `docs/roadmap/principles.md` - Core design principles
+- `docs/roadmap/core-principles-extracted.md` - 15 extracted principles
+- `docs/roadmap/simplicity-principles.md` - 15 simplicity principles  
+- `docs/roadmap/master-principles.md` - Attempt at consolidation
+
+### Semantic & Economic Insights (KEEP AS SEPARATE TOPICS)
+- `docs/roadmap/semantic-revolution.md` - Semantic understanding
+- `docs/roadmap/the-semantic-insight.md` - Core semantic insight
+- `docs/roadmap/economic-analysis.md` - Cost economics
+- `docs/roadmap/mini-whitepaper.md` - Cost-centric analysis
+
+### Technical Documents (KEEP)
+- `docs/roadmap/technical-architecture.md` - Implementation details
+- `docs/roadmap/migration-strategy.md` - Migration guide
+- `docs/roadmap/business-model.md` - Business strategy
+- `docs/roadmap/attack-defense-insights.md` - Security analysis
+- `docs/roadmap/mcp-comparison-insights.md` - MCP comparison
+- (removed) `docs/roadmap/function-as-agent.md` - superseded by Share & Find
+
+### Journey Documents (KEEP)
+- `docs/roadmap/discussion-journey.md` - Our discussion history
+
+## Proposed New Structure
+
+### 1. Core Principles Document (`docs/roadmap/core-principles.md`)
+Consolidate the best of all principle documents into categories:
+- Fundamental Laws (3-5 most important)
+- Design Principles (8-10 key principles)
+- Implementation Principles (5-8 practical guidelines)
+- Meta-Principles (3-5 principles about principles)
+
+### 2. Topic-Specific Documents
+Keep these as deep dives into specific aspects:
+- Semantic insights
+- Economic analysis  
+- Security considerations
+- Technical architecture
+
+### 3. Reference Documents
+- Mini white paper
+- Migration strategy
+- Business model
+
+## Consolidation Strategy
+
+1. **Identify Duplicates**: Many principles appear in multiple files with slight variations
+2. **Choose Best Expression**: Pick the clearest, most insightful version
+3. **Eliminate Redundancy**: Each principle appears once in the most appropriate section
+4. **Maintain Coherence**: Ensure principles flow logically
+5. **Preserve Insights**: Don't lose valuable nuances in consolidation
+
+## Key Principles to Definitely Keep
+
+From various documents:
+1. Cost Conservation Law (成本守恒)
+2. Behavior Over Identity (行为优于身份)  
+3. Function as Primitive (函数即基元)
+4. Simplicity Enables Robustness (简单促进健壮)
+5. Semantic Understanding Changes Everything (语义改变一切)
+6. Work as Authentication (工作即认证)
+7. Local Experience Trumps Global (局部胜全局)
+8. Immunity Over Prevention (免疫优于预防)
+9. Time Heals and Reveals (时间治愈并揭示)
+10. Natural Selection Works (自然选择有效)

connectonion/docs/archive/archive/core-principles-extracted.md

@@ -0,0 +1,239 @@
+# Core Useful Principles from ConnectOnion Discussion
+
+## 1. Cost Conservation Law
+**成本守恒定律**
+
+Costs in systems can only be transferred, never eliminated. Every "simplification" shifts cost somewhere else.
+
+```
+Traditional: Developer complexity → User configuration
+ConnectOnion: Upfront design → Zero runtime config
+```
+
+**Insight**: Accept the cost where it creates least friction. We take complexity in protocol design so developers get simplicity.
+
+## 2. Behavior Over Identity
+**行为优于身份**
+
+Trust emerges from consistent behavior patterns, not pre-assigned credentials.
+
+```python
+# Not: "I am trusted because I have certificate X"
+# But: "I am trusted because I consistently deliver Y"
+```
+
+**Application**: Every system should evaluate based on actions, not labels.
+
+## 3. Function as Primitive
+**函数即基元**
+
+The simplest useful unit in computing is a function. Build everything from functions.
+
+```python
+# Everything is just:
+input → function → output
+
+# Even complex systems:
+agent = function
+network = function(function)
+trust = function(behavior_history)
+```
+
+**Power**: Maximum composability with minimum concepts.
+
+## 4. Local Experience Trumps Global Reputation
+**局部经验胜过全局声誉**
+
+Your direct experience matters more than what others say.
+
+```
+Trust hierarchy:
+1. My experience with you (100% weight)
+2. My friend's experience (30% weight)  
+3. Network reputation (10% weight)
+4. Unknown (0% trust)
+```
+
+**Resilience**: Cannot be gamed by fake reviews or Sybil attacks.
+
+## 5. Topology as Natural Defense
+**拓扑即天然防御**
+
+Physical/network topology limits create natural security boundaries.
+
+```
+Dunbar's number (~150) = Natural connection limit
+Local network first = Natural boundary
+Time delays = Natural rate limiting
+```
+
+**Elegance**: Security through natural constraints, not artificial rules.
+
+## 6. Progressive Enhancement
+**渐进式增强**
+
+Start where you are, enhance towards the ideal.
+
+```
+Day 1: Works on current internet
+Day 100: Works better with peers
+Day 1000: Optimal with full adoption
+Always: Backwards compatible
+```
+
+**Adoption**: No "flag day" migrations needed.
+
+## 7. Semantic Understanding Changes Everything
+**语义理解改变一切**
+
+When protocols understand meaning, not just syntax, magic happens.
+
+```python
+# These find each other automatically:
+"I need translation" → finds → "I translate text"
+"Generate summary" → finds → "I summarize documents"
+```
+
+**Revolution**: Discovery without directories.
+
+## 8. Simplicity at Interface, Complexity in Implementation
+**接口简单，实现复杂**
+
+Users see simplicity. Complexity exists but is hidden.
+
+```python
+# User sees:
+agent = discover("translation")
+result = agent("Hello")
+
+# Hidden: Behavioral matching, trust calculation, routing...
+```
+
+**Success**: Complexity you don't see doesn't hurt you.
+
+## 9. Time Heals and Reveals
+**时间治愈并揭示**
+
+Time naturally solves many security problems.
+
+- New agents = naturally untrusted
+- Consistent behavior + time = trust
+- Bad actors + time = exposed
+- No activity + time = forgotten
+
+**Beauty**: No complex reputation algorithms needed.
+
+## 10. Composition Over Configuration
+**组合优于配置**
+
+Build capabilities through composition, not configuration files.
+
+```python
+# Not: 
+config = {
+  "plugins": ["translator", "summarizer"],
+  "settings": {...100 lines...}
+}
+
+# But:
+agent = translate + summarize + analyze
+```
+
+**Developer Joy**: Code that reads like intent.
+
+## 11. Failure as Feature
+**失败即特性**
+
+Systems that gracefully handle failure are antifragile.
+
+```python
+translators = discover_all("translation")
+for t in translators:
+    try:
+        return t(text)
+    except:
+        continue  # Natural failover
+```
+
+**Robustness**: No single point of failure.
+
+## 12. Selection Cost as Quality Filter
+**选择成本即质量过滤器**
+
+Making selection costly naturally filters out bad actors.
+
+```
+Sandbox testing = Preparation cost
+Time to build trust = Patience cost
+Limited connections = Opportunity cost
+```
+
+**Natural Selection**: Good actors willing to pay, bad actors filtered out.
+
+## 13. Network Effects from Day One
+**第一天起的网络效应**
+
+Value must exist for the first user, not just the millionth.
+
+```
+User 1: Gets 100 pre-seeded agents
+User 2: Gets 101 agents (100 + User 1's)
+User N: Gets N-1 + 100 agents
+```
+
+**Growth**: Every user adds value for all others.
+
+## 14. Behavioral Fingerprints
+**行为指纹**
+
+Actions create unique, unforgeable signatures over time.
+
+```python
+fingerprint = hash(all_past_behaviors)
+# Cannot be faked without doing the work
+# Naturally evolves with agent growth
+```
+
+**Security**: Past behavior predicts future behavior.
+
+## 15. The O(n²) to O(1) Transform
+**O(n²)到O(1)的转换**
+
+The core value: Transform quadratic integration cost to constant.
+
+```
+Traditional: n agents = n² integrations
+ConnectOnion: n agents = n discoveries
+
+From: "How do I connect to X?"
+To: "X, are you there?"
+```
+
+**Economics**: This transformation justifies everything.
+
+## Meta-Principles
+
+### Principle Generation Principle
+Good principles are:
+- **Observable** in nature
+- **Testable** in code
+- **Valuable** in practice
+- **Simple** to state
+- **Profound** in implication
+
+### The Ultimate Test
+Ask: "Does this make developers' lives simpler while making the system more powerful?"
+
+If yes → Keep
+If no → Discard
+
+### The Philosophy
+We're not building a protocol. We're recognizing patterns that already exist in nature and making them accessible to code.
+
+## Conclusion
+
+These principles emerged from asking: "What if agents could collaborate as naturally as people at a marketplace?"
+
+The answer: Remove artificial barriers (IDs, certificates, configurations) and amplify natural patterns (behavior, reputation, local trust).
+
+The future of computing isn't more protocols - it's fewer barriers.

connectonion/docs/archive/archive/master-principles.md

@@ -0,0 +1,222 @@
+# Master Principles of ConnectOnion
+
+## The Trinity of Core Insights
+
+### 1. Cost Conservation (成本守恒)
+**Costs can only be transferred, never eliminated.**
+- We transfer complexity from developers to protocol designers
+- We transfer integration cost from runtime to design time
+- We transfer trust verification from certificates to behavior
+
+### 2. Behavior Over Identity (行为优于身份)
+**Identity emerges from consistent behavior patterns.**
+- Trust is earned through action, not granted by authority
+- Past behavior predicts future behavior
+- No certificates can fake a behavioral history
+
+### 3. Simplicity Enables Robustness (简单促进健壮)
+**Complex systems are fragile; simple systems are antifragile.**
+- 100 lines of code > 1000 pages of specification
+- Natural selection works on simple rules
+- Complexity should emerge, not be designed
+
+## The Fundamental Principles
+
+### Principle 1: Function as Primitive (函数即基元)
+Everything is a function:
+```python
+agent = function
+network = function(function)
+trust = function(behavior_history)
+discovery = function(semantic_need)
+```
+
+### Principle 2: Work as Authentication (工作即认证)
+The best proof of ability is doing the work:
+```python
+# Not: "I have a certificate"
+# But: "Here's the result"
+```
+
+### Principle 3: Local Experience Trumps Global Reputation (局部胜全局)
+Your experience matters most:
+```
+My experience: 100% weight
+Friend's experience: 30% weight
+Network reputation: 0% weight (we don't use it!)
+```
+
+### Principle 4: Semantic Understanding Changes Everything (语义改变一切)
+When protocols understand meaning:
+```python
+"I need translation" → finds → "I translate text"
+# No configuration needed
+```
+
+### Principle 5: Time Heals and Reveals (时间治愈并揭示)
+Time is a natural filter:
+- New agents = naturally untrusted
+- Good behavior + time = trust
+- Bad behavior + time = exposure
+- No activity + time = forgotten
+
+### Principle 6: Topology as Defense (拓扑即防御)
+Natural boundaries create security:
+- Dunbar's number (~150) limits connections
+- Local network creates natural boundary
+- Time delays create rate limiting
+
+### Principle 7: Immunity Over Prevention (免疫优于预防)
+Make attacks pointless, not impossible:
+```
+Sybil attack → Creates 1000 real workers
+Reputation gaming → No global reputation to game
+Fake capabilities → Exposed by testing
+```
+
+### Principle 8: Progressive Enhancement (渐进式增强)
+Evolution beats revolution:
+```
+Day 1: Works on current internet
+Year 1: Works better with behavioral routing
+Year 10: Pure behavioral network
+Always: Backwards compatible
+```
+
+### Principle 9: Composition Over Configuration (组合优于配置)
+Build through combination:
+```python
+# Not: config.json with 1000 lines
+# But: agent = translate + summarize + analyze
+```
+
+### Principle 10: Natural Selection (自然选择)
+Let the network evolve:
+- Good agents get used more
+- Bad agents naturally disappear
+- No enforcement needed
+
+## The Meta-Principles
+
+### The Complexity Trap Principle
+Every solution creates new problems:
+```
+Problem → Solution → New Problem → More Solutions → System Collapse
+```
+**Wisdom**: Stop adding, start removing.
+
+### The Elegance Principle
+The right solution feels obvious in hindsight:
+- If it's not beautiful, it's not right
+- If it needs extensive documentation, it's too complex
+- If a child can't understand it, rethink it
+
+### The 100-Line Test
+If your protocol can't be implemented in 100 lines, it's too complex.
+
+### The Natural System Principle
+Study nature, not computer science:
+- Markets work without IDs
+- Ant colonies coordinate without managers
+- Love happens without certificates
+
+## The Economic Principles
+
+### O(n²) to O(1) Transformation
+The core value proposition:
+```
+Traditional: n agents = n² integrations
+ConnectOnion: n agents = n discoveries
+```
+
+### Network Effects from Day One
+Value for the first user, not just the millionth:
+```
+User 1: Gets 100 pre-seeded agents
+User 2: Gets 101 agents
+User N: Gets N-1 + 100 agents
+```
+
+### Selection Cost as Quality Filter
+Making selection costly filters bad actors:
+- Sandbox testing = preparation cost
+- Building trust = patience cost
+- Limited connections = opportunity cost
+
+## The Design Principles
+
+### Attraction Not Addressing (吸引而非寻址)
+Messages attracted by behavior, not sent to addresses:
+```python
+# Not: send_to("agent://id-123")
+# But: broadcast(need="translation")
+```
+
+### Dynamic Trust (动态信任)
+Trust changes with behavior:
+- No permanent certificates
+- Trust increases with success
+- Trust decreases with failure
+- Trust fades without interaction
+
+### Layered Complexity (层次化复杂度)
+Match verification to risk:
+```python
+translate("Hello") # Simple, fast
+transfer_funds(1000) # Multiple confirmations
+```
+
+### Collective Intelligence (群体智慧)
+Network smarter than individuals:
+- Individual nodes stay simple
+- Complex verification through collaboration
+- Emergent intelligence from simple rules
+
+## The Philosophical Core
+
+### Identity is Fluid
+"Who you are" < "What you do"
+
+### Trust is Earned
+Not granted by authority but built through action
+
+### Intelligence is Distributed
+No single point of control or failure
+
+### Systems Evolve
+Like nature, the network adapts and improves
+
+## The Ultimate Wisdom
+
+### 少即是多 (Less is More)
+- Fewer features, more robustness
+- Fewer rules, more adaptability
+- Fewer barriers, more innovation
+
+### 道法自然 (Follow Nature's Way)
+- Nature has no IDs but perfect coordination
+- Study ecology, not technology
+- Evolution beats intelligent design
+
+### 大道至简 (The Greatest Way is Simple)
+- TCP/IP is simple, thus successful
+- HTTP is simple, thus ubiquitous
+- ConnectOnion must be simple to succeed
+
+## The Final Test
+
+Before adding anything, ask:
+1. Does nature do it this way?
+2. Can it be simpler?
+3. Does it make developers' lives easier?
+4. Can it be explained to a child?
+
+If any answer is "no", reconsider.
+
+## Conclusion
+
+These principles are not rules to follow but patterns we've recognized. They're not inventions but discoveries. They existed before we found them and will exist after we're gone.
+
+The future network doesn't ask "Who are you?" but "What can we do together?"
+
+**记住：复杂性是熵，简单性是生命。**