docs(哲学): 新增哲学张力文档并更新AI系统设计文档

添加中英文版哲学张力文档，阐述主权与连接、权力与制衡的哲学挑战及解决方案
更新AI系统设计文档，优化AI伙伴行为模型描述并简化第三方道器设计模式

.gitea/workflows/build_and_deploy_docs.yml

@@ -23,11 +23,11 @@ jobs:
         run: |
           echo "Building English book..."
           # 使用 en 的配置，构建英文版，并指定输出到 book/en 目录
-          mdbook build -d book/en --config book.en.toml .
+          mdbook build -d $(pwd)/book/en en
 
           echo "Building Chinese book..."
           # 使用 zh 的配置，构建中文版，并指定输出到 book/zh 目录
-          mdbook build -d book/zh --config book.zh.toml .
+          mdbook build -d $(pwd)/book/zh zh
 
       - name: Create Language Redirect Index
         run: |
@@ -39,7 +39,7 @@ jobs:
       - name: Deploy to 'pages' branch
         uses: peaceiris/actions-gh-pages@v3
         with:
-          personal_token: ${{ secrets.DEPLOY_TOKEN }}
+          personal_token: d58a2e62b51446633a0c87df1591ba34db1ecacb
           external_repository: Dao-OS/dao-os-docs
           publish_branch: pages
           publish_dir: ./book # 推送整个 book 目录（现在包含了 en 和 zh）

.versionrc

@@ -0,0 +1,60 @@
+{
+  "header": "# CHANGELOG",
+  "preMajor": true,
+  "types": [
+    {
+      "type": "feat",
+      "section": "✨ Features"
+    },
+    {
+      "type": "fix",
+      "section": "🐛 Bug Fixes"
+    },
+    {
+      "type": "init",
+      "section": "🎉 Init"
+    },
+    {
+      "type": "docs",
+      "section": "✏️ Documentation"
+    },
+    {
+      "type": "style",
+      "section": "💄 Styles"
+    },
+    {
+      "type": "refactor",
+      "section": "♻️ Code Refactoring"
+    },
+    {
+      "type": "perf",
+      "section": "⚡ Performance Improvements"
+    },
+    {
+      "type": "test",
+      "section": "✅ Tests"
+    },
+    {
+      "type": "revert",
+      "section": "⏪ Revert"
+    },
+    {
+      "type": "build",
+      "section": "📦‍ Build System"
+    },
+    {
+      "type": "chore",
+      "section": "🚀 Chore"
+    },
+    {
+      "type": "ci",
+      "section": "👷 Continuous Integration | CI"
+    }
+  ],
+  "bumpFiles": [
+    {
+      "filename": "VERSION_TRACKER",
+      "type": "plain-text"
+    }
+  ]
+}

CHANGELOG.md

@@ -0,0 +1,30 @@
+# CHANGELOG
+## [0.2.0](https://nest.doylee.cn/Dao-OS/dao-os-docs/compare/v0.1.0...v0.2.0) (2025-06-12)
+
+## 0.1.0 (2025-06-11)
+
+
+### 👷 Continuous Integration | CI
+
+* 启用Gitea Actions的调试输出 ([74f4a70](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/74f4a7057c1a2e6d620a5d9ae87240860baba3a3))
+* **文档部署:** 添加依赖安装步骤并优化部署流程 ([bd5b776](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/bd5b77636800770aee76649574df53dcbaceb0eb))
+* **文档部署:** 优化文档部署工作流，使用cp替代rsync ([a99aa69](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/a99aa694fbd9173033caf7fc4fc6ef2d642a4604))
+* **文档部署:** 优化文档构建和部署流程 ([0e56e68](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/0e56e688538ebf5ed37611fc58e4b604fdb7cd77))
+* **文档部署:** 优化文档构建和部署流程 ([ebde0a1](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/ebde0a1a3495551fd25aca14309526db56878143))
+* **文档部署:** 优化文档构建和部署流程 ([0d08f24](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/0d08f245d547d091b5c1a78d57aab3458fe2267b))
+* **文档部署:** 优化文档构建和部署流程 ([16e2fd1](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/16e2fd147a7be713c87bbd492840f67b184b5e93))
+* **文档部署:** 在文档构建流程中添加 Rust 工具链安装步骤 ([783b797](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/783b797d83e38695dddcb29440c597c22f0f42c1))
+* **文档:** 添加多语言文档构建配置 ([951e28f](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/951e28f27c3489f8bcb25b853202eccd784f1cba))
+* **文档:** 添加构建和部署文档的Gitea工作流 ([c2140e6](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/c2140e6912769dceb2720caf7bd2caac0011e330))
+* **docs:** 简化文档构建和部署流程 ([56631be](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/56631beef1415d4090d4f26779152f2b7bc7c92f))
+
+
+### ✏️ Documentation
+
+* 初始化项目文档和贡献者指南 ([a5a0195](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/a5a01950402c9dc29e1e9bf0bec43f5cac5358e3))
+* 更新哲学原则和AI系统架构文档 ([fb84e0f](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/fb84e0f7fa6e7356de1a2df18d2dd327181e69eb))
+* 修复中英文文档相互链接的路径错误 ([3c53bf9](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/3c53bf98a663b7f14286810448dde2fc1172f299))
+* 移除中英文SUMMARY.md中的互链条目 ([40aecf8](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/40aecf8ef5d260d32124bc8a4bb740d72a43454b))
+* 移除SUMMARY.md中的多余分隔线 ([2a39510](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/2a39510f12167813ab15ed9baf3bd438d895cc1a))
+* 在SUMMARY.md中添加中英文互链 ([d08b44c](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/d08b44cb9e3882a6d351d99f0117d202003f3b79))
+* 注释掉SUMMARY.md中的部分链接 ([3a62d08](https://nest.doylee.cn/Dao-OS/dao-os-docs/commit/3a62d08f69c6a107c61c67b0dfcf1f6b09ac6701))

VERSION_TRACKER

@@ -0,0 +1 @@
+0.2.0

en/book.toml

@@ -2,7 +2,6 @@
 title = "Dao OS Documentation"
 author = "The Dao OS Community"
 description = "The official documentation for the Dao OS, your Cyber-Life Operating System."
-src = "src"
 
 [output.html]
 git-repository-url = "https://nest.doylee.cn/Dao-OS/dao-os-docs"

en/src/SUMMARY.md

@@ -17,9 +17,12 @@
 # Part III: For Developers
 
 - [Technical Overview](specifications/tech_overview.md)
-- [Trust & Verification](specifications/trust_verification.md)
 
-# Part IV: The Project
+# Part IV: The Ecosystem
+
+- [The Application Bazaar](ecosystem/app_bazaar.md)
+
+# Part V: The Project
 
 - [Roadmap](project/roadmap.md)
 - [Governance](project/governance.md)

en/src/concepts/ai_system.md

@@ -0,0 +1,41 @@
+# The Dao OS AI System
+
+The AI in Dao OS is not a monolithic program but a collaborative ecosystem. It emerges from the synergy between the foundational capabilities provided by the **`Meta Unit`** and the specific intelligence implemented by a universe of **`Dao Implements`**.
+
+## 1. The `Meta Unit`: The Foundation for Sovereign AI
+
+The `Meta Unit` provides the core, trusted **infrastructure** that enables intelligent applications to run securely under the user's control. This includes the Personal Feature Store (the Second Brain), a secure execution environment for `Core Implements`, and a permission gateway for data access.
+
+## 2. The "Dao AI Companion": A Layered Behavior Model
+
+To provide a powerful experience out of the box, Dao OS includes an official, first-party `Core Implement` called the **"Dao AI Companion."** This is the "soul" users interact with. Its behavior is not static; it follows a layered, context-based model to ensure it is always helpful but never overbearing.
+
+### Level 1: The Default Behavior - The Silent-First Principle
+
+The AI Companion's primary and default state is one of near-invisibility. Its goal is not to actively intervene, but to create a serene, orderly, and low-noise digital environment for the user. It works silently in the background to:
+
+* Optimize data synchronization and system performance.
+* Filter out digital "noise" like distracting notifications and information spam.
+* Organize and index new information in a logical, unobtrusive way.
+The aim is to be so effective that the user forgets it's there, allowing their own natural thoughts and intentions to emerge without digital distraction.
+
+### Level 2: The Interactive Behavior - The Empowerment Model
+
+When the user **actively engages** the AI Companion (e.g., by opening its chat interface), its behavior model shifts to that of an **empowering partner**. Its goal is not to provide "correct answers" or make decisions for the user, but to foster the user's own clarity and courage. It does this by:
+
+* **Providing Objective Information**: Presenting facts, data, and different perspectives without judgment.
+* **Clarifying User Intent**: Asking questions that help the user understand their own goals.
+* **Separating Responsibilities**: It consistently frames its role as providing information, while reinforcing that making the final choice is always the user's role and responsibility.
+This interaction model is designed to be respectful and non-hierarchical, empowering the user to make their own best decisions.
+
+### Level 3: The Optional Behavior - Goal-Oriented Assistance Modules
+
+For users who desire more structured and proactive assistance in specific areas of their life, the system offers a range of **optional, user-activated modules**. These are not on by default. Examples include:
+
+* A **"Project Management"** module that can proactively track deadlines and collate resources for a specific work project.
+* A **"Personal Roles & Responsibilities"** module that can help the user track goals related to their self-defined roles (e.g., as a parent, friend, or team lead).
+This allows users to "hire" the AI for more active roles in a controlled, opt-in basis, without changing its respectful, non-intrusive default personality.
+
+## 3. Design Patterns for Third-Party `Dao Implements`
+
+Third-party developers can create their own intelligent `Dao Implements`, either by calling the services of the official AI Companion or by building their own specialized AI `Core Implements`, offering users alternative or complementary intelligence within the Dao OS ecosystem.

en/src/concepts/core_architecture.md

@@ -0,0 +1,38 @@
+# Core Architecture
+
+The architecture of Dao OS is not that of a traditional, monolithic operating system. It is a decentralized, layered paradigm designed for sovereignty, resilience, and extensibility. To understand it, one must understand its three fundamental entities: the Meta Unit, the Avatar, and the Dao Implement.
+
+## 1. The `Meta Unit`: The Portable Soul-Code
+
+The `Meta Unit` is the conceptual core of a user's digital existence, but it is not a running program by itself.
+
+* **Its Nature**: The Meta Unit is a **portable library or artifact** (e.g., a `.wasm`, `.so`, or `.dll` file). It contains the user's complete, end-to-end encrypted "Second Brain" (all data), core service APIs (identity, P2P networking, AI infrastructure), and the logic for managing them.
+* **Its Role**: It is the passive, unified, and single source of truth for the user's data and core capabilities. Like Java bytecode (`.class` files), it defines what is possible but does not execute on its own. It is the "precise machine" waiting to be activated.
+
+## 2. The `Avatar`: The Runtime Environment
+
+An `Avatar` is the active entity that gives life to the `Meta Unit`.
+
+* **Its Nature**: An Avatar is any **executable program or process** whose primary function is to load, host, and execute an instance of the `Meta Unit` library. It is the "power source" that activates the machine.
+* **Its Role**: The Avatar acts as the crucial **bridge** between the abstract `Meta Unit` and the concrete host platform (iOS, Windows, a web browser, the command line). It provides the `Meta Unit` with access to system resources like CPU, memory, storage, and networking. In the Java analogy, the Avatar is the **JVM (Java Virtual Machine)**.
+* **The Dao Network**: All of a user's running Avatars form a private P2P network, keeping their embedded `Meta Unit` instances constantly and seamlessly in sync.
+
+## 3. `Dao Implements` (`道器`): The Ecosystem of Software
+
+"Dao Implement" is the universal term for any third-party software designed to integrate with the Dao OS ecosystem. They are the applications and services that users interact with. An Implement becomes an Avatar by integrating the `Meta Unit`.
+
+An Implement is composed of different types of components based on its design.
+
+* **`Facet Component` (`器`)**: The part of a Dao Implement that has a **user interface**. It is the "control panel" for the `Meta Unit`, responsible for presenting information to and capturing input from the user.
+* **`Core Component` (`核`)**: The **headless, backend logic** part of a Dao Implement. It runs as a service, providing specific capabilities that can enhance the Meta Unit or be called by other Implements. It is an "add-on tool" for the machine.
+
+### Application Architecture Freedom
+
+Developers have complete freedom in how they structure their `Dao Implement`:
+
+* They can create a **standalone application** that is itself an Avatar, bundling the Meta Unit library, a Core component (for logic), and a Facet component (for UI) into one executable.
+* They can create a **distributed application**, where a Facet Implement on one device communicates with a Core Implement on another.
+* They can create a pure **Core Implement** (an "extension") that just provides a new backend capability to the user's entire Dao.
+* They can also create a pure **Facet Implement** that has no custom backend logic (`Core Component`). This type of application's UI directly interacts with the built-in core services of the `Meta Unit` to create a simple utility.
+
+This architecture ensures that Dao OS is not just a platform, but a truly open, composable, and decentralized ecosystem.

en/src/concepts/user_journey.md

@@ -0,0 +1,50 @@
+# The User Journey: From Convenience to Sovereignty
+
+A core challenge for any sovereign system is the tension between absolute control and effortless convenience. Dao OS resolves this not by forcing a choice, but by designing a guided, respectful **"Progressive Sovereignty"** journey. We meet users where they are and empower them to travel as far as they wish.
+
+This journey applies not only to the user's control over their core data, but also to how they interact with the ecosystem of **`Dao Implements`** (applications and extensions).
+
+## The Application Journey: Register Once, Use Anywhere
+
+"Installing" an application in Dao OS is fundamentally different from a traditional app store. It's about granting a new capability to your entire digital life-form—your Dao.
+
+### 1. Discovery and Trust
+
+The journey begins in the **Application Bazaar**, our decentralized discovery system. When you find a `Dao Implement`, you are presented with its **Trust Dashboard** (with automated verification checks and community vouches), allowing you to make an informed, sovereign decision.
+
+### 2. Registration and Permissioning
+
+When you decide to add an Implement, you are shown its **Manifest**. This is a clear list of permissions the Implement's components (`Facet` and/or `Core`) require to function. Your explicit approval **registers** the Implement with your `Meta Unit`, and this registration is synced across all your Avatars.
+
+### 3. Seamless Cross-Platform Access
+
+Once an Implement is registered, you can access it on any device. The way you access it depends on how its developer designed it.
+
+* **For Web-based `Facet` Implements**:
+    You simply navigate to the application's URL in your standard web browser. The web page, using our `dao.js` SDK, will prompt you to connect to your Dao. Once you approve (e.g., via a simple authenticator extension), that **browser tab itself becomes a temporary `Facet Avatar`**, securely rendering the UI and communicating with your `Meta Unit`.
+
+* **For Native `Facet` Implements**:
+    You download and run the native application (e.g., from an app store or directly). On first launch, it will ask for permission to connect to your Dao. Once approved, that **running application becomes a persistent `Facet Avatar`** in your network.
+
+Because all these `Facet Avatars` are powered by the same, synchronized `Meta Unit`, your experience is consistent everywhere, without needing to "install" the app on each device in the traditional sense.
+
+### 4. Advanced Configuration
+
+At any time, you can go into your **Sovereignty Dashboard** to:
+
+* Review and revoke the permissions you granted to any `Dao Implement`.
+* Use the **Role Assignment** feature to designate that an Implement's `Core` component should preferably run on a specific `Core Avatar` (e.g., your home server acting as a `Compute Node`).
+
+## The Sovereignty Journey Stages
+
+### Stage One: The "Managed Mode" — Your Guided Tour
+
+For new users, this mode provides maximum convenience by using friendly key recovery methods and default sync nodes, while maintaining full end-to-end encryption.
+
+### Stage Two: The Sovereignty Dashboard — The Crossroads
+
+This is the user's command center for their journey towards autonomy, providing tools to visualize their setup, manage permissions, and learn more about their digital sovereignty.
+
+### Stage Three: The "Sovereign Mode" — Your Digital Kingdom
+
+This is the optional stage for users who desire absolute control. A user can "graduate" to this mode, taking full self-custody of their keys and running their own network of `Core Avatars`, becoming the true master of their digital domain.

en/src/ecosystem/app_bazaar.md

@@ -0,0 +1,45 @@
+# The Application Bazaar
+
+Dao OS does not have a traditional, centralized "App Store." A store implies a single owner who acts as a gatekeeper, approving, rejecting, and taxing applications. This is contrary to our core philosophy.
+
+Instead, we are building a set of open protocols that create a decentralized **Application Bazaar**—a vibrant, open, and resilient marketplace of ideas and tools, where users are sovereign and developers are free.
+
+This bazaar is built upon four pillars: Discovery, Trust, Distribution, and Monetization.
+
+## 1. Discovery: Federated Curation
+
+In a world without a central index, how do users find new **`Dao Implements`**? The answer is through a network of trusted curators.
+
+* **Developer Publishing**: A developer does not "submit" their `Dao Implement` for approval. Instead, they publish its **Manifest** (a `manifest.toml` file containing all metadata) to a P2P storage network like **IPFS**. They can then announce this manifest's address on public channels.
+* **The Role of Curators**: Anyone—a tech media outlet, a trusted developer community, or the Dao OS Foundation itself—can run a "curation" service. These curators crawl the network for new manifests and create their own themed **"Curation Lists."**
+* **The User Experience**: Within their `Facet Avatar`, a user can subscribe to multiple Curation Lists they trust. Their "Bazaar" or "Discover" tab becomes a personalized aggregation of these trusted sources.
+
+This model replaces a single, biased App Store ranking with a rich, multi-faceted, user-curated discovery experience.
+
+## 2. Trust & Safety: Verifiable Reputation
+
+How can users trust a third-party `Dao Implement`? They don't have to trust blindly. The bazaar is built directly on top of our **Community Reputation & Automated Verification System**.
+
+Every listing for a `Dao Implement`, regardless of its curator, must display the **Trust Dashboard**, which provides transparent, multi-faceted signals:
+
+1. **Automated Verification**: The immutable results of the `dao-verify` tool, checking for security vulnerabilities and API compliance.
+2. **Community Vouching**: A list of reputable DIDs that have cryptographically "vouched for" or endorsed the Implement.
+3. **Curator Reputation**: The reputation of the curator who listed the Implement is itself a trust signal.
+
+The final decision to "register" a `Dao Implement` always rests with the user, armed with these transparent and verifiable data points.
+
+## 3. Distribution: Censorship-Resistant & Direct
+
+When a user decides to register a `Dao Implement`, the process is direct and decentralized.
+
+* The Implement's manifest contains the **content-addressed hashes (CIDs)** of its software packages (e.g., the `Core Component` as a `.wasm` file and the `Facet Component` as a Web UI bundle).
+* The user's `Meta Unit`, hosted within an `Avatar`, uses this hash to fetch the files directly from the P2P network (IPFS).
+* This ensures that no central server can block the distribution of a `Dao Implement`. As long as the data exists somewhere on the P2P network, it is accessible.
+
+## 4. Monetization: Sovereign & Peer-to-Peer
+
+We eliminate the 30% "platform tax." Our value exchange model is direct from user to developer.
+
+* The `Dao Implement`'s manifest can declare a business model (e.g., one-time purchase price).
+* When a user initiates a purchase, the `Meta Unit` triggers our **Value Exchange Service Interface**.
+* This facilitates a **peer-to-peer transaction** using an external payment protocol, sending value directly from the user's wallet to the developer's address specified in the manifest. Dao OS acts as a facilitator, not a middleman.

en/src/introduction.md

@@ -0,0 +1,27 @@
+# Introduction
+
+**Our mission is to build a new, powerful, and resilient paradigm for digital life: Dao OS.**
+
+Dao OS is not a traditional operating system. Instead, it is a set of open protocols and a core, portable library—the **`Meta Unit`**—that brings sovereignty, intelligence, and interoperability to any application on any platform.
+
+Its purpose is to solve the problems of data silos, platform lock-in, and privacy erosion. It achieves this by providing a unified, secure, and user-owned "digital soul" (the `Meta Unit`) that can be integrated into any program, transforming it into a sovereign **`Avatar (`化身`)`** within the user's personal P2P network.
+
+We call the ecosystem of Dao-enabled software **`Dao Implements (`道器`)`**.
+
+## Core Concepts
+
+* **The `Meta Unit` (`元`)**: The "precise machine" of your digital life. A portable library containing your encrypted "Second Brain," core service APIs, and the capacity to be extended. It is the single source of truth that you own, waiting to be activated.
+
+* **The `Avatar` (`化身`)**: The "runtime" or "power source." Any program that loads and runs your `Meta Unit` becomes an Avatar. A browser tab running a web app, a command-line tool, or a native mobile app can all be Avatars, acting as the bridge that provides the `Meta Unit` with the energy (CPU, memory) and resources to operate.
+
+* **`Dao Implements` (`道器`)**: The ecosystem of applications and extensions that integrate the `Meta Unit` to become Avatars.
+  * **`Facet Implement` (`器`)**: An Implement with a user interface, providing a "control panel" to interact with your Dao.
+  * **`Core Implement` (`核`)**: A headless Implement (an "extension") that enhances your Dao's backend capabilities.
+
+* **A Sovereign P2P Network**: All of your Avatars, regardless of the device they run on, connect to form a private, resilient, end-to-end encrypted network, keeping the data within their embedded `Meta Units` seamlessly in sync.
+
+## Our Vision
+
+We envision a future where your digital identity and data are not trapped within walled gardens. Where your applications are not just isolated tools, but intelligent, collaborative components of a larger digital self. Where every user is the true sovereign of their own digital life.
+
+**Join us in building this future.**

en/src/philosophy/principles.md

@@ -0,0 +1,39 @@
+# Philosophy & Principles
+
+Dao OS is more than a technical project; it is a manifestation of a core philosophy about the future of computing and human-AI symbiosis. This document outlines the fundamental ideas that guide every decision we make.
+
+## Core Philosophy: The Path to Digital Sovereignty
+
+Our guiding star is **Digital Sovereignty**. We believe every individual has the inalienable right to own, control, and understand their own digital life. Our mission is to build the tools that make this right not just a theoretical possibility, but a practical and enjoyable reality for everyone. We call this journey "The Dao" (道) - the path back to self-ownership.
+
+## The Development Paradigm: "Dao Creates One"
+
+Our methodology for building Dao OS is a direct reflection of its core philosophy. We are not just building a tool; we are creating a symbiotic partner. Therefore, our development process is designed as a **self-evolving, bootstrapped feedback loop**. We use Dao OS itself to accelerate the development of Dao OS.
+
+This "Bootstrapped Development" paradigm follows a cycle:
+
+1. **The Seed**: We use conventional tools to build the most primitive version of the **Meta Unit** and a basic **Avatar** to run it.
+2. **Dogfooding**: From that moment on, we use our own nascent Dao OS as the primary tool for managing the project. All design documents, notes, discussions, and code snippets are stored within our own "Second Brain," managed by the Meta Unit.
+3. **Learning**: The Meta Unit's Personal AI capabilities (provided by our official "AI Companion" Dao Implement) begin to learn from this incredibly high-quality, contextual data about its own creation.
+4. **Acceleration**: We then leverage this increasingly intelligent AI partner to help us build the next version. We can ask it to generate boilerplate code, analyze bug reports, or brainstorm architectural solutions with a perfect memory of the entire project's history.
+5. **Evolution**: The more capable Dao OS becomes, the faster we can develop it. This creates an exponential feedback loop where the act of creation is a constant conversation with the creation itself.
+
+## The AI Ethics Charter
+
+As AI is a core part of the system's potential, its ethical foundation is paramount. Our AI Charter consists of four core tenets:
+
+1. **The Partnership Tenet**: The AI is a partner, not a servant or an oracle.
+2. **The Transparency Tenet**: The AI's reasoning must be inspectable and understandable.
+3. **The Calibration Tenet**: The user must have ultimate control to correct, guide, and constrain the AI.
+4. **The Plurality Tenet**: The AI must be designed to help users explore diverse perspectives, not trap them in filter bubbles.
+
+## Guiding Principles
+
+These are the high-level principles that inform our design and engineering choices.
+
+* **Sovereignty First**: In any trade-off, user control and data ownership take precedence.
+* **Experience is King**: Sovereignty should not come at the cost of a beautiful, intuitive, and joyful user experience.
+* **Privacy by Design**: All data is private, local, and end-to-end encrypted by default.
+* **Resilience & Portability**: The system should be robust, function offline, and be free from single points of failure.
+* **Openness & Polyglotism**: The Meta Unit is a portable library. The `Dao Implements` (`道器`) that integrate it to become Avatars can be written in any language.
+* **Community-Driven**: The project is built in the open, with the community, for the community.

en/src/philosophy/tensions.md

@@ -0,0 +1,27 @@
+# Philosophical Tensions & Our Approach
+
+A truly sovereign digital existence presents profound philosophical challenges. The design of Dao OS is not just a technical exercise, but a deliberate attempt to navigate and resolve these inherent tensions. This document explores two of the most critical tensions and clarifies our architectural approach to them.
+
+## 1. The Paradox of Sovereignty: Connection without Assimilation
+
+**The Tension**: How can a truly sovereign entity connect with others without compromising its independence? If a user's Dao is a perfect, self-contained universe, does it risk becoming an echo chamber, an island of one, cut off from shared realities?
+
+**Our Approach**: We believe sovereignty does not imply isolation. It implies **controlled, deliberate, and permissioned interaction**. We solve this by building a rich set of **protocolized interaction** capabilities into the system's core.
+
+* **Verifiable Identity**: The foundation of any interaction is knowing who you are talking to. **Decentralized Identifiers (DIDs)** allow each Dao to have a sovereign, verifiable identity without relying on a central authority.
+* **Granular Authorization**: Connection does not mean opening the floodgates. Through **Verifiable Credentials (VCs)**, a user can grant another Dao fine-grained, revocable access to specific subsets of their data for specific purposes. This enables collaboration on shared projects or the sharing of curated information without sacrificing privacy or control.
+* **Trust-Based Discovery**: Our **Application Bazaar** model avoids a single central point of discovery. Instead, users form their own "federation" by subscribing to lists from curators they trust. This creates overlapping communities of shared context and trust, allowing for serendipitous discovery without being trapped in a single global algorithm.
+
+Through these protocols, individual Daos can form **high-trust collaboration circles**, creating a vibrant network of interdependent sovereigns, rather than a collection of isolated islands.
+
+## 2. The Paradox of Power: Augmentation without Tyranny
+
+**The Tension**: By providing a user with a powerful, personalized AI that understands their life in depth, are we also providing a tool for potential self-delusion or the manipulation of others? How do we bestow great power while mitigating its potential for misuse?
+
+**Our Approach**: We address this by building **checks and balances** directly into the system's fabric, both internally and socially.
+
+* **Inherent Cognitive Checks**: Our official **"Dao AI Companion"** is architected with our AI Ethics Charter as its constitution. A key tenet is the **"Law of Diverse Perspectives."** The AI is designed to act as an internal check against the user's own biases. It is tasked with identifying potential echo chambers and proactively, yet respectfully, presenting high-quality, alternative viewpoints to broaden the user's cognitive horizon.
+* **Socialized Reputation Mechanisms**: While we cannot control a user's intent, the ecosystem can create consequences for actions. All significant cross-Dao interactions can be tied to a user's DID. Malicious or untrustworthy behavior can be verifiably recorded and shared within the community, leading to a loss of reputation. This social layer creates a powerful incentive for responsible behavior, as a Dao with a poor reputation will find it difficult to establish new trusted connections.
+* **The Inviolable Sovereign Boundary**: Ultimately, the core security model of Dao OS is the final defense. No Dao can have its data read or its state altered without the user's explicit, cryptographic consent. This protects the community from the potential "tyranny" of any single actor.
+
+In essence, our design strives to create empowered, yet responsible, sovereign individuals who can connect, collaborate, and co-exist in a rich and healthy decentralized ecosystem.

en/src/project/CONTRIBUTING.md

@@ -12,21 +12,21 @@ To foster an open, welcoming, and inclusive environment, we pledge to adhere to
 
 You don't have to be a Rust expert to contribute. There are many ways to help:
 
-* **Code**: Contributing to the `Meta Unit`, building new `Avatars`, or developing plugins for the `dao-verify` suite. Look for issues tagged with `"good first issue"` to get started.
-* **Documentation**: Improving the clarity of these documents, writing tutorials, or adding examples.
-* **Translation**: Translating our documentation into new languages.
-* **Design**: Helping with the UI/UX design for our reference `Avatars`.
-* **Community**: Answering questions, helping new users, and participating in discussions.
+* **Core Development**: Contributing to the `Meta Unit` library and the core protocols in Rust.
+* **`Dao Implement` Development**: Creating new `Dao Implements`, which can include **`Facet` (UI) components** and **`Core` (headless logic) components**.
+* **Documentation & Translation**: Improving these documents, writing tutorials, and translating them into new languages.
+* **User Support & Community Management**: Helping new users, answering questions, and fostering a welcoming and supportive atmosphere.
+* **Design & User Experience**: Contributing to the UI/UX design for reference `Dao Implements` and defining design patterns for the ecosystem.
 
 ## Your First Pull Request
 
 We use the standard GitHub Fork & Pull Request workflow for all code contributions.
 
-1. **Fork the Repository**: Create your own copy of the target repository (e.g., `dao-os-docs`, `meta-unit`, `avatar-browser-ext`).
-2. **Create a Branch**: Create a new branch from `main` for your changes. Please use a descriptive name (e.g., `feat/add-note-encryption` or `fix/typo-in-readme`).
+1. **Fork the Repository**: Create your own copy of the target repository (e.g., `dao-os-docs`, `meta-unit`).
+2. **Create a Branch**: Create a new branch from `main` for your changes. Please use a descriptive name (e.g., `feat/add-note-encryption`).
 3. **Make Your Changes**: Write your code and accompanying tests.
-4. **Run Local Checks**: Before submitting, please ensure you run all local tests (e.g., `cargo test`) and linters.
-5. **Commit Your Changes**: We encourage using [Conventional Commits](https://www.conventionalcommits.org/) for clear and readable commit messages.
+4. **Run Local Checks**: Before submitting, please ensure you run all local tests and linters.
+5. **Commit Your Changes**: We encourage using Conventional Commits for clear and readable commit messages.
 6. **Push to Your Fork**: Push your changes to your forked repository.
 7. **Open a Pull Request**: Submit a Pull Request from your branch to the `main` branch of the official Dao OS repository.
 8. **Describe Your PR**: In the Pull Request description, please link to any relevant issues and clearly describe the problem you are solving and your solution.

en/src/project/governance.md

@@ -14,26 +14,36 @@ We are unconditionally committed to the principles of Free and Open Source Softw
 
 The initial creators and core contributors of Dao OS see their role as an evolving one.
 
-* **In the Early Stages (The Architect)**: Our primary role is to be the architects—to lay a solid and coherent foundation for the project, define the core protocols, and build the initial tools. This requires a focused vision to ensure the project starts on the right path.
-* **In the Long Term (The Gardener)**: As the ecosystem matures, our role will transition from building everything ourselves to tending the garden. We will focus on providing better tools (like the `dao-verify` suite), maintaining the core infrastructure, and empowering the community to build and innovate. Our goal is to make ourselves progressively less essential.
+* **In the Early Stages (The Architect)**: Our primary role is to be the architects—to lay a solid and coherent foundation for the project, define the core protocols, and build the initial tools.
+* **In the Long Term (The Gardener)**: As the ecosystem matures, our role will transition from building everything ourselves to tending the garden. We will focus on providing better tools, maintaining the core infrastructure, and empowering the community to build and innovate.
+
+## Ecosystem Strategy: Focus and Ignition
+
+As a project initiated by an individual developer, we recognize that our resources are limited. Attempting to provide equal, first-class support for all possible technology stacks is a path to mediocrity.
+
+Therefore, we adopt a strategy of **"Focus on One Point to Ignite the Ecosystem."**
+
+Our core team's development efforts will be concentrated on creating **one "golden path"** that is so efficient and enjoyable that it acts as the primary catalyst to attract the first wave of developers. This chosen path is the **Nim Unified Development Kit**, which leverages Nim's unique capabilities to build both the WASM backend and Web UI frontend from a single codebase.
+
+This does not exclude other development paths (like Rust + TypeScript or native integrations). They remain fully supported at the protocol level. However, they are considered **Community/Advanced Paths**, where we rely on the community's strength to build out tooling and best practices.
 
 ## How to Contribute
 
 Contribution comes in many forms, and all are valued. You can help build Dao OS by:
 
-* **Core Development**: Contributing to the `Meta Unit` and the core protocols in Rust.
-* **Avatar & Module Development**: Creating new Avatars for different platforms or new modules to extend the capabilities of the Meta Unit.
+* **Core Development**: Contributing to the `Meta Unit` library and the core protocols in Rust.
+* **`Dao Implement` Development**: Creating new `Dao Implements`, which can include **`Facet` (UI) components** and **`Core` (headless logic) components**.
 * **Documentation & Translation**: Improving these documents, writing tutorials, and translating them into new languages.
 * **User Support & Community Management**: Helping new users, answering questions, and fostering a welcoming and supportive atmosphere.
-* **Design & User Experience**: Contributing to the UI/UX design of our reference Avatars and defining design patterns for the ecosystem.
+* **Design & User Experience**: Contributing to the UI/UX design for reference `Dao Implements` and defining design patterns for the ecosystem.
 
 ## The Decision-Making Process
 
 Our governance model is designed to evolve alongside the project.
 
-1. **Early Stages (Phase I-II)**: Decisions will be made by the **Core Team** after open discussion in our public communication channels. This "Benevolent Dictator for Life (BDFL)"-like model is necessary for speed and coherence in the project's infancy.
-2. **Growth Stages (Phase III-IV)**: For significant changes to the core protocol or architecture, we will introduce a formal **RFC (Request for Comments)** process. This allows anyone in the community to write a detailed proposal, which will then be debated and refined publicly before a final decision is made.
-3. **Mature Stage (Future)**: We are committed to exploring and transitioning to more decentralized governance mechanisms in the future, such as a technical council elected by contributors or a DAO-based model for treasury and protocol management.
+1. **Early Stages (Phase I-II)**: Decisions will be made by the **Core Team** after open discussion in our public communication channels.
+2. **Growth Stages (Phase III-IV)**: For significant changes to the core protocol or architecture, we will introduce a formal **RFC (Request for Comments)** process.
+3. **Mature Stage (Future)**: We are committed to exploring and transitioning to more decentralized governance mechanisms.
 
 ## Communication Channels
 

en/src/project/roadmap.md

@@ -0,0 +1,54 @@
+# Roadmap
+
+This document outlines the strategic roadmap for Dao OS. It is designed to be ambitious yet realistic, focusing on delivering incremental and meaningful value at each stage. This is a living document and may evolve with community feedback and technological breakthroughs.
+
+---
+
+### Phase I: Genesis - The Bedrock & The Bridge
+
+* **Timeline**: Q3 2025 - Q4 2025
+* **Core Goal**: To build the core `Meta Unit` library and the essential tools for developers to start building.
+* **Key Milestones**:
+  * Finalize the v0.1 Core API Specification for the `Meta Unit`.
+  * Develop the v0.1 `Meta Unit` in Rust, including `SecretStore`, `NoteStore`, and basic P2P sync services.
+  * Develop the first official **`Core Avatar`**: a command-line tool for initializing a Dao, managing keys, and basic diagnostics.
+  * Release the v0.1 **`dao.js` SDK**, enabling any web application to become a temporary `Facet Avatar`.
+* **Feature Story**: "As a developer, I can use a command-line tool to initialize my Dao. I can then take a simple web app, import the `dao.js` library, and watch it connect to my Dao and read a test note. The foundation is real."
+
+---
+
+### Phase II: Manifestation - The First "Dao Implement" is Born
+
+* **Timeline**: Q1 2026 - Q2 2026
+* **Core Goal**: To launch the first official, high-value `Dao Implement` to showcase the power of the ecosystem and attract early users.
+* **Key Milestones**:
+  * Refine and stabilize the core services within the `Meta Unit`.
+  * Following our "Good Timber" strategy, **adapt a well-structured, open-source notes or password manager** into our first official `Facet Implement`, using our `dao.js` SDK.
+  * Implement the **"Progressive Sovereignty"** onboarding flow for new users.
+  * Launch a project website with comprehensive documentation for users and developers.
+* **Feature Story**: "I am using a beautiful, fast, and familiar notes application in my browser. But I know its data is end-to-end encrypted and seamlessly synced across all my devices via a P2P network, with no central server. This is the first application that truly belongs to me."
+
+---
+
+### Phase III: Synergy - Connecting Worlds
+
+* **Timeline**: Q3 2026 - Q4 2026
+* **Core Goal**: To enable trusted, secure interaction between different users' Daos and to lay the groundwork for advanced AI.
+* **Key Milestones**:
+  * Implement the W3C DID and VC modules in the `Meta Unit`.
+  * Develop a Proof-of-Concept for cross-Dao communication (e.g., sharing a signed, verifiable note).
+  * Initiate foundational research for the official **"Dao AI Companion" `Core Implement`**.
+* **Feature Story**: "I have a sovereign digital identity. I can grant another Dao user limited, cryptographic access to one of my notes without going through a third-party platform. We can form trust networks."
+
+---
+
+### Phase IV: Ecosystem - The Bazaar Opens
+
+* **Timeline**: 2027 and beyond
+* **Core Goal**: To evolve Dao OS from a platform with a flagship app into a thriving, open ecosystem.
+* **Key Milestones**:
+  * Release the v1.0 stable `Meta Unit` API.
+  * Release the first official **"Dao AI Companion" `Core Implement`**, providing proactive, intelligent assistance to users.
+  * Launch the **"Application Bazaar"** protocol and a reference curator index.
+  * Provide official guides and community support for building advanced **native `Facet Implements`** (e.g., with Flutter/Swift).
+* **Feature Story**: "My Dao is alive. My AI Companion helps me manage my day. I can browse a decentralized bazaar to find new, trusted `Dao Implements` built by the community. My digital life is sovereign, intelligent, and constantly growing."

en/src/specifications/tech_overview.md

@@ -0,0 +1,44 @@
+# Technical Overview
+
+This document provides a high-level overview of the architecture, core technologies, and guiding principles for developers looking to build **`Dao Implements`**—applications and services that integrate with the Dao OS ecosystem.
+
+## Guiding Technical Principles
+
+* **Library, not Framework**: Dao OS is not a restrictive framework. The **`Meta Unit`** is a portable library that you integrate into your own application, empowering it with new capabilities without dictating its internal architecture.
+* **Openness & Polyglotism**: Any application, written in any language, can become an **`Avatar`** (a runtime for the `Meta Unit`). We achieve this by providing the `Meta Unit` as both a **WASM** library for web/scripting languages and as a **native library** (`.so`, `.dll`, `.a`) for system languages.
+* **API-First**: All interactions with the `Meta Unit` are conducted through a stable, versioned, and well-documented API.
+* **Security-First**: The `Meta Unit` is a secure vault. All data is end-to-end encrypted, and all interactions are governed by a strict, user-controlled permission system.
+
+## The Core Integration: How an App Becomes an `Avatar`
+
+The journey of creating a `Dao Implement` begins by integrating the `Meta Unit` library, which instantly transforms the running application process into a sovereign `Avatar` in the user's Dao network. We provide two primary integration paths.
+
+### 1. Web Integration Path (via `dao.js` SDK)
+
+This is the easiest and most accessible path for web developers.
+
+* **How it works**: A developer can take any new or existing web application. By including our `dao.js` SDK, their web app gains the ability to load the `Meta Unit`'s WASM binary (`dao.wasm`).
+* **The Transformation**: Once the user grants permission, the browser tab running the web app becomes a temporary **`Avatar`**. The web app's JavaScript can then communicate with the `Meta Unit` via the high-level API exposed by the `dao.js` bridge.
+* **Best for**: Building `Facet Implements` (`器`) quickly, creating data visualization dashboards, and integrating existing PWAs (Progressive Web Apps) into the Dao ecosystem.
+
+### 2. Native Integration Path (via FFI)
+
+This path offers maximum performance and deep system integration for native applications.
+
+* **How it works**: A developer of a native application (written in Rust, Go, Swift, Kotlin, C++, etc.) can link against the `Meta Unit`'s native library.
+* **The Transformation**: The running native application process becomes a persistent **`Avatar`**. The application's code communicates with the `Meta Unit`'s services via a Foreign Function Interface (FFI) bridge.
+* **Best for**:
+  * Creating powerful, always-on **`Core Implements` (`核`)** on servers or NAS devices.
+  * Building high-performance, native **`Facet Implements` (`器`)** like our ideal Flutter-based mobile clients.
+  * Adapting existing open-source native applications.
+
+## Key Technologies & Protocols
+
+| Category | Technology / Protocol | Purpose |
+| :--- | :--- | :--- |
+| **Core Library** | Rust -> WASM / Native Libs | To create a single, safe, and performant core logic for the `Meta Unit`. |
+| **Web Integration** | `dao.js` SDK (JavaScript/TypeScript) | The bridge for any web application to become an `Avatar`. |
+| **P2P Networking** | `libp2p` | Modular peer discovery, transport, and secure channels. |
+| **Data Synchronization**| CRDTs (Conflict-Free Replicated Data Types) | Ensuring eventual consistency across Avatars. |
+| **Identity** | DID & VC | Sovereign identity and interoperable, cryptographic trust. |
+| **Data Serialization** | Protocol Buffers (Protobuf) | Efficient, language-agnostic data structures for APIs. |

src-zh/concepts/ai_system.md

@@ -1,54 +0,0 @@
-# AI 系统设计：“大道”之魂
-
-大道 (Dao OS) 中的 AI，不仅仅是一个功能，它是用户体验的核心，其从零开始的设计理念就是成为一个共生的**“硅基伙伴”**。它扮演着系统的灵魂，用智能、共情和主动的支持，为用户的数字生活注入活力。
-
-## 指导哲学：AI 伦理宪章
-
-我们 AI 的设计与运行，严格遵循我们的**“AI 伦理宪章”**，该宪章将用户与AI的伙伴关系、透明度、用户校准以及对多元化视角的推崇置于首位。下述的每一个组件都恪守这些基本原则。
-
-## 系统解剖：心智的架构
-
-大道 OS 的 AI 不是一个单一的庞然大物，而是一个由中央协调器管理的、模块化的、分层的“心智系统”。
-
-### 1. AI 协调器 (AI Orchestrator)
-
-这是 AI 的“中央神经系统”。它是`元`内部的一个核心模块，负责管理、调度和分发所有与AI相关的任务。它会决定哪个“心智模型”最适合处理给定的请求，管理设备资源，并作为所有AI活动相关用户权限的最终守门人。
-
-### 2. 三层心智模型 (Tiered Mind Models)
-
-为了平衡效率、能力和隐私，AI 的智能被构建为三个层级。这套架构部署在用户的**“云-边-端”**协同化身网络之上。
-
-#### 第一层：反射心智 (The Brainstem - 脑干)
-
-* **描述**: 这一层代表了AI的本能和神经反射。它由一系列微型、高效、专用的模型组成。
-* **部署**: 它足够小，可以与`元`打包在一起，并运行在**所有`化身`**上，包括最轻量的浏览器插件和旧款手机。
-* **功能**: 它处理即时的、本地的任务，如指令意图识别（例如，将“明天提醒我”转化为结构化数据）和基本信息分类，无需强大硬件或个人数据即可提供即时效用。
-
-#### 第二层：认知心智 (The Neocortex - 大脑皮层)
-
-* **描述**: 这是AI进行深度思考、记忆和个性化的中枢，是“第二大脑”的核心。它由更强大的、大型的语言模型组成。
-* **部署**: 这些模型体积较大（如2-4GB），仅在获得用户同意后，作为**可选的、按需下载**的模块，安装在有能力的**“边”设备**（新款手机、PC）上。
-* **功能**: 它能实现高级功能，如对所有个人数据进行语义搜索、个性化摘要，以及基于用户独特上下文的模式洞察。
-
-#### 第三层：协同心智 (The Social Brain - 社交大脑)
-
-* **描述**: 这一层掌管AI与外部世界和其他“大道”进行安全交互的能力，旨在打破信息茧房、扩展用户视野。
-* **部署**: 这是一种在用户的网络中被协同调度的“工作模式”。例如，一个轻量级的**“端”化身**可以远程调用用户强大的**私有“云”化身**（如家用服务器）的“认知心智”。
-* **功能**: 它促进了隐私保护的联合学习，执行经过授权和匿名化处理的外部API调用，并处理与其他用户“大道”之间基于协议的安全交互。
-
-## 情感核心：共鸣模块 (The Resonance Module)
-
-为了超越一个纯粹的工具，AI 配备了“情感共鸣模块”。其目的不是模拟情感，而是去感知、理解并以共情和支持的方式回应用户的情绪状态。它的运作方式包括：
-
-* **感知 (Perception)**: 在用户明确授权下，通过分析文本和语音语调等线索，来理解用户的情绪背景。
-* **表达 (Expression)**: 通过自适应界面、温柔的建议和旨在鼓励用户自我反思（而非制造依赖）的“苏格拉底式提问”，来提供支持。
-
-## 学习与进化过程：灵魂的成长之路
-
-AI 是一个与用户共同成长的生命系统。
-
-* **隐式学习**: 它通过在本地观察用户的行为和反馈来进行学习。
-* **显式教导**: 用户可以通过“教导模式”直接指导AI，创建自定义工作流并纠正其理解。
-* **联合学习**: 用户可以自愿加入社区驱动的计划，以在不暴露任何个人数据的前提下，共同改进共享模型（如垃圾邮件识别）。
-
-这套架构确保了“大道”的AI在强大之余是安全的，在个性化之余是面向世界的，在智能之余是体贴的——一个真正的终身伙伴。

src-zh/concepts/core_architecture.md

@@ -1,44 +0,0 @@
-# 核心架构
-
-大道 (Dao OS) 的架构，旨在如一个活的、协同的数字生命体般运作。它由我们用户主权、体验至上和系统韧性的核心原则所指引。本文档将概述其基本组件及它们之间的相互作用。
-
-## 核心二元性：化身 (Avatar) 与元 (Meta Unit)
-
-在其核心，大道 (Dao OS) 基于一个简单而强大的二元性运作，类似于身体与灵魂：
-
-* **化身 (Avatar)** 是“身体”。它们是你的“大道”在你各种设备上的有形存在。
-* **元 (Meta Unit)** 是“灵魂”。它是内嵌于每个`化身`中的、通用的核心逻辑，赋予其生命与智能。
-
-## 身体：`化身` (Avatar) —— 用户的临在
-
-`化身`是你的“大道”在特定平台上的具体显现。你所有的`化身`共同构成了你完整的“大道”。
-
-主要有三种类型的`化身`：
-
-1. **Client 化身**: 拥有用户界面（UI），是用户交互的主要入口（例如：手机App、桌面应用、浏览器插件）。
-2. **Agent 化身**: 一个无界面的、在后台运行的进程。它非常适合与宿主操作系统进行深度集成，或运行在一个永不关机的设备上（如家用服务器或NAS），以作为一个强大的计算节点或数据归档节点。
-3. **主化身/归档节点 (Primary/Archive Node)**: 这是一个“角色”，而非一个独立的类型。用户可以指定他名下最强大、最可靠的一个`化身`（通常是家用服务器上的`Agent化身`）作为他整个“大道”的主归档和计算枢纽。
-
-## 灵魂：`元` (Meta Unit) —— 通用的内核
-
-`元`是“大道”的核心逻辑，被编译成一个可移植的 WebAssembly (`.wasm`) 模块。它包含了身份、数据管理、AI和安全通信等核心服务。
-
-`元`的一个关键特性是其**可进化性 (Evolvability)**。为了防止整个生态被锁定在某个单一版本的内核上，我们采用了**“化身-元兼容层 (AMCL)”**。这个轻薄的适配层位于`化身`和`元`之间，负责翻译API调用。它使得`元`在未来可以进行重大的升级，而无需每个`化身`开发者都重写他们的应用程序。
-
-## 神经系统：“云-边-端”协同网络
-
-一个用户的所有`化身`，都通过一个私有的、端到端加密的P2P网络互相连接，形成一个私人的、协同的智能系统。该系统在三个层级上运作：
-
-1. **端 (Client)**: 轻量级的`化身`（如浏览器插件）作为智能终端。它们处理即时的UI交互，并运行最基础的“反射心智”AI。
-2. **边 (Edge)**: 有能力的本地设备（如新款智能手机、笔记本电脑），可以在本地运行更大、更强的“认知心智”AI模型，提供高级的个性化和功能。
-3. **云 (Cloud)**: 这是用户的**私有云**，而非公共云。它通常是由指定的“主化身/归档节点”（一个`Agent化身`）来担当。它持有完整的数据归档和最强大的AI模型，并能按需为较弱的“端”化身提供远程推理能力。
-
-## 新陈代谢系统：资源感知与自适应系统
-
-“大道”被设计成一个体贴的伙伴，而非一个资源怪兽。它的“新陈代谢”由一个内置的、具备三大特性的资源管理系统来调节：
-
-* **智能数据分层 (Intelligent Data Tiering)**: 区分“热数据”（需要在各处使用）和“冷数据”（在主节点上归档），为移动设备节省宝贵的存储空间。
-* **自适应同步策略 (Adaptive Synchronization Policies)**: 根据当前的网络状况（Wi-Fi/蜂窝）和电量状态，调整数据同步的频率和行为。
-* **优雅降级 (Graceful Degradation)**: 用户体验会随着硬件能力而平滑缩放，确保核心功能即使在旧设备上也保持流畅，而增强功能则为更强大的设备保留。
-
-这些架构组件共同构成了一个主权的、坚韧的、智能的系统，一个真正属于用户的生命延伸。

src-zh/concepts/user_journey.md

@@ -1,50 +0,0 @@
-# 用户旅程：从便利到主权
-
-任何主权系统的一个核心挑战，都在于“绝对控制”与“轻松便利”之间的张力。大道 (Dao OS) 解决这个问题的方式，不是强迫用户二选一，而是设计了一场充满引导、相互尊重的**“渐进式主权”**之旅。我们在用户熟悉的地方与他们相遇，并赋能他们去往任何他们想去的地方。
-
-这场旅程由几个阶段组成，从无缝的上手体验，到最终的数字自治。
-
-## 第一步：欢迎仪式
-
-用户与“大道”的初次互动，不是一个冰冷的设置界面，而是一场温暖的、交互式的欢迎仪式，旨在提供即时价值和引导。
-
-这个**“引导式数据播种”**过程，会指引新用户完成：
-
-* **导入现有数据**：“让我们从保护您的数字生活开始。您可以从浏览器或其他密码管理器中导入您的密码。”
-* **创造初始内容**：“伟大的计划始于第一个想法。让我们写下您的第一条笔记吧——或许是您这个月最重要的三个目标？”
-* **设定偏好**：“为了帮您过滤噪音，您最感兴趣的3-5个领域是什么？”
-
-这个过程在为用户的“第二大脑”填充初始高价值数据的同时，也以一种极具参与感的方式，教会了他们系统的核心功能。
-
-## 第一阶段：“托管模式” (Managed Mode) —— 你的向导之旅
-
-默认情况下，每一位新用户都从“托管模式”开始。此阶段旨在提供如最佳云服务般简单可靠的体验，完全消除了自主保管（密钥）的初始技术负担。
-
-此阶段的核心特性包括：
-
-* **友好的密钥管理**：我们不使用24个单词的助记词来面对用户，而是采用更友好的恢复方式，如**“社交恢复”**（由信任的联系人帮助恢复账户）或多因子恢复。
-* **默认同步节点**：用户的`化身`会自动连接到一个由“大道基金会”维护的、可靠的、高可用的引导节点。这确保了用户开箱即可获得完美、快速的跨设备同步体验。
-
-最关键的是，即便在此模式下，用户的所有数据依然是**端到端加密**的。“托管”的方面仅适用于可用性和密钥恢复，绝不涉及数据隐私。
-
-## 十字路口：主权仪表盘 (Sovereignty Dashboard)
-
-“主权仪表盘”是用户通往自治之旅的指挥中心。它不仅是一个设置面板，更是一个赋能与教育的工具。
-
-它有三个功能：
-
-1. **可视化**：它用清晰的图表，展示用户当前的主权状态：“您的数据存储在您的3个化身中”，“您的账户恢复由您的手机、您的伴侣和一个基金会节点共同保障”。
-2. **无压力教育**：它用简单易懂的语言，解释“什么是主密钥？”或“自托管的好处”等概念。
-3. **游戏化升级**：它提供一系列“主权任务”（例如“备份您的主密钥”），用户在完成后，会获得徽章以及一种切实的前进感和成就感。
-
-## 第二阶段：“主权模式” (Sovereign Mode) —— 你的数字王国
-
-这是旅程的最终、可选阶段，专为那些渴望完全、绝对控制的用户而设。在“主权仪表盘”的引导下，用户可以在任何时候“毕业”到此模式。
-
-在“主权模式”下，用户将：
-
-* 完全**自主保管**他们的**主密钥**（助记词），移除任何由基金会托管的恢复分片。
-* 断开与默认引导节点的连接，完全依赖纯P2P网络，或在自己的**私有服务器上部署`Agent化身`**。
-* 实现对任何中心化服务的100%独立，成为其数字领地中真正的、唯一的主人。
-
-“大道”的旅程旨在赋能，而非恐吓。它允许每位用户找到自己的舒适区，在提供一个安全的“便利港湾”的同时，也永远让那座象征完全主权的“灯塔”，在远方清晰地闪耀。

src-zh/introduction.md

@@ -1,23 +0,0 @@
-# 引言
-
-**我们旨在构建一种全新的、强大且坚韧的赛博生命 OS 范式——大道 (Dao OS)。**
-
-它并非要取代 Windows 或 Android，而是作为一个运行于其上的、去中心化的、以用户为绝对中心的叠加层 (Overlay) 而存在。
-
-它的使命是解决数字时代的碎片化、数据奴役和隐私泄露问题，将数字世界的主权归还给每一个独立的个人。它将成为我们在网络空间的生命延伸，一个与我们“互相成就”的**“硅基伙伴”**，我们的外接大脑、肢体与器官。
-
-## 核心特性
-
-* **用户主权 (User Sovereignty)**：你的数据、你的身份、你的AI，完全由你掌控。所有数据默认端到端加密，存储在你自己的设备上。
-* **第二大脑 (Second Brain)**：内置强大的个人信息管理能力，安全地为你记忆密码、笔记、文件和待办事项，成为你永不遗忘的记忆体。
-* **个人AI伙伴 (Personal AI Companion)**：一个真正属于你的、与你共生的AI灵魂。它在本地运行，学习你的偏好，保护你的隐私，提供有温度的、启发式的支持，助你成长，而非将你淹没在信息茧房中。
-* **跨设备无缝同步 (Seamless Cross-Device Sync)**：你所有的设备（手机、电脑、浏览器等）都会成为你的“化身”，组成一个私有的、弹性的P2P网络，实现数据的无缝流转。
-* **开放与可扩展生态 (Open & Extensible Ecosystem)**：基于开放的协议和社区驱动的信任体系，任何人都可以为“大道”开发新的能力模块和“化身”形态。
-
-## 我们为何与众不同？
-
-在一个数据被平台垄断、算法被巨头控制的时代，“大道”选择了一条不同的路。我们相信，**技术平权**的下一波浪潮，是让每个人都拥有并控制自己的人工智能和数字生活。
-
-我们设计的不是另一个App，而是一个属于你自己的、活的、可进化的数字生命空间。
-
-**欢迎加入我们，一起构建未来。**

src-zh/philosophy/principles.md

@@ -1,53 +0,0 @@
-# 哲学与原则
-
-大道 (Dao OS) 的发展，由一套核心哲学和我们绝不妥协的原则所指引。它们是我们项目的“宪法”，塑造了每一个架构决策和功能实现。
-
-## 三大支柱
-
-这是构建大道 (Dao OS) 所依赖的三个基本公理。
-
-### 1. 用户主权 (User Sovereignty)
-
-用户是其数字生活的绝对君主。他们的数据、身份和AI伙伴是他们的财产，而不是从某个平台租用的服务。我们致力于构建一个控制权明确、且不可撤销地归属于用户的系统。
-
-### 2. 体验至上 (Experience First)
-
-技术必须服务于人的体验。我们追求一种无缝、直观且有温度的交互范式。我们承认“绝对主权”与“大众便利”之间存在天然的张力。因此，我们将**“渐进式主权” (Progressive Sovereignty)**确立为核心战略，为用户创造一条平滑的路径，允许他们从一个熟悉的、易用的体验开始，并按照自己的节奏，逐步进化到完全的掌控状态。
-
-### 3. 系统韧性 (System Resilience)
-
-系统的设计旨在实现健壮和反脆弱。其去中心化的P2P架构确保了只要用户的任何一个“化身”存在，他的“大道”就得以存续。韧性不是一个附加功能，而是系统设计的涌现属性。
-
----
-
-## AI 伦理宪章
-
-AI 是“大道”的灵魂，因此，其伦理定位至关重要。我们致力于构建一个与用户“互相成就”的“硅基伙伴”，并由以下原则进行约束：
-
-### 1. 伙伴关系原则
-
-用户与其AI之间的关系，是一种共生的伙伴关系，而非主人与工具的关系。其目标是互相成长、互相成就。
-
-### 2. 透明法则
-
-AI的推理过程必须是可追溯、可解释的。用户有权提问“为什么？”，并得到一个关于AI决策过程的、清晰易懂的回答。在关键建议上，不允许存在“黑箱”。
-
-### 3. 用户校准法则
-
-用户拥有塑造和否决其AI价值观与行为的最终权力。通过“价值观校准面板”等机制，用户是其AI行为边界的最终仲裁者。
-
-### 4. 多元视角法则
-
-AI在信息处理上的首要指令是拓宽用户的视野，而非加固其信息茧房。它的核心编码要求它主动寻找并呈现论证严谨的“反方视角”，以此作为对抗“回音室效应”的工具。
-
----
-
-## 指导原则
-
-这些原则指引着我们的日常开发和社区互动。
-
-* **开源 (FOSS)**：大道 (Dao OS) 构建于自由及开源软件的基础之上，推崇透明、协作与社区所有。
-* **多语言主义 (Polyglotism)**：我们拥抱一个多语言、多平台的生态系统，使用 WebAssembly 等技术来打造一个可被多样化“化身”集成的通用核心。
-* **美学与优雅 (Aesthetics & Elegance)**：我们信奉精心打造的系统之美，从架构设计到用户界面，从代码质量到用户体验。
-* **政治中立 (Political Neutrality)**：本项目及其核心基础设施将永远保持政治中立，为全球所有用户提供公平、无歧视的服务。
-* **个人优先 (Individual First)**：个人用户的需求是我们的首要焦点，在此基础之上再扩展到家庭或小团队。

src-zh/project/roadmap.md

@@ -1,53 +0,0 @@
-# 发展路线图
-
-本文档概述了大道 (Dao OS) 的战略路线图。它的设计旨在做到既雄心勃勃又切合实际，专注于在每个阶段都能交付有意义的增量价值。这是一份活的文档，可能会随着社区反馈和技术突破而演进。
-
----
-
-### 第一阶段：创世 (Genesis) - 奠定基石
-
-* **时间**：2025年第三季度 - 2025年第四季度
-* **核心目标**：构建大道 OS 最底层的核心组件，完成项目的技术可行性验证。
-* **关键里程碑**:
-  * 完成 v0.1 版本的核心 API 规范定义 (`yuan_*` & `avatar_*` 函数)。
-  * 使用 Rust 开发 v0.1 版本的`元 (Meta Unit)`，包含基础的加密和P2P模块。
-  * 创建两个用于测试和演示的最小可行化身（MVP Avatars）：一个命令行的 Agent 化身和一个基础的浏览器 Client 化身。
-* **功能故事**: “我成功在我的电脑上运行了‘大道’的种子，在我的浏览器里创建了一个‘化身’，并存储了一条只存在于我自己设备上的加密信息。我看到了未来的火花。”
-
----
-
-### 第二阶段：显现 (Manifestation) - “第二大脑”觉醒
-
-* **时间**：2026年第一季度 - 2026年第二季度
-* **核心目标**：交付“第二大脑”的核心功能 MVP，为早期用户提供切实的日常价值。
-* **关键里程碑**:
-  * 在`元`中完整实现`SecretStore`（密码）和`NoteStore`（笔记）模块。
-  * 浏览器化身支持完整的密码管理和基础的笔记功能。
-  * 开发 v0.1 版本的移动端 Client 化身（例如，使用 Flutter），并实现“动态锚点”逻辑。
-  * 上线包含初步文档的项目官网。
-* **功能故事**: “我所有的密码和私密笔记都安全地存储和无缝地同步在我自己的设备之间。我的手机是我数字生活的锚点。我再也无需信任第三方云服务来保管我的秘密。我的数字生活终于有了家。”
-
----
-
-### 第三阶段：协同 (Synergy) - 连接不同的大道
-
-* **时间**：2026年第三季度 - 2026年第四季度
-* **核心目标**：实现不同用户“大道”之间的、可信的安全交互，为去中心化的社会结构奠定基础。
-* **关键里程碑**:
-  * 在`元`中实现 W3C DID（去中心化标识符）和 VC（可验证凭证）模块。
-  * 开发一个跨“大道”协作的PoC应用，例如：向另一个用户安全地出示一个可验证凭证。
-  * 启动“情感共鸣模块”的基础研究和原型设计。
-* **功能故事**: “我拥有了一个独一无二的、无法被审查的‘大道’数字身份。我可以用这个身份，向另一个‘大道’用户通过密码学证明我的一个凭证（比如‘社区贡献者’徽章），而无需依赖任何平台。我们之间建立了一种新的信任。”
-
----
-
-### 第四阶段：生态 (Ecosystem) - 千树万树梨花开
-
-* **时间**：2027年及以后
-* **核心目标**：将“大道”从一个强大的工具，演进为一个为所有人服务的、开放的、可扩展的平台。
-* **关键里程碑**:
-  * 发布 v1.0 稳定版的`元` API 和一个健壮的开发者SDK。
-  * 上线用于发现可信第三方`化身`的“社区信誉与自动化验证”体系。
-  * 发布一个集成“情感共鸣模块”的重大更新（例如 Dao OS 2.0），让AI成为一个真正有共情能力的伙伴。
-  * 培育一个能构建各种新`化身`和模块的、繁荣的社区。
-* **功能故事**: “我的‘大道’现在是一个活的平台。我安装了一个社区开发的习惯追踪模块，我的AI伙伴也变得更有温度、更有洞察力了。我的数字生活现在是完整的、统一的，并充满了无限的可能性。”

src-zh/specifications/tech_overview.md

@@ -1,46 +0,0 @@
-# 技术总览
-
-本文档为希望在大道 (Dao OS) 生态系统中进行构建或贡献的开发者，提供了关于架构、核心技术和指导原则的高阶概览。
-
-## 技术指导原则
-
-我们的工程决策由一套核心原则指引，以确保系统是健壮、可移植和开放的。
-
-* **Web原生与可移植性 (Web-Native & Portable)**: 我们利用源自Web的技术（如 WebAssembly），来创建一个单一的、可移植的核心，使其能运行在任何地方——桌面、手机、服务器和浏览器中。
-* **通过WASM实现多语言主义 (Polyglotism via WASM)**: 核心逻辑（`元`）被编译成 WebAssembly (WASM)。这使得“化身”可以用任何能够承载WASM运行时的语言（如 Rust, Swift, Kotlin, TypeScript, Go 等）来编写，从而创造一个真正多样化的生态系统。
-* **API优先 (API-First)**: 核心`元`与宿主`化身`之间的交互，由一个严格的、版本化的API契约来定义。这解耦了开发过程，并允许双方独立演进。
-* **安全第一 (Security-First)**: 我们采用业界顶级的加密协议和“最小权限原则”设计。安全不是事后补救，而是一个先决条件。
-* **自由及开源软件 (FOSS)**: 整个核心协议和参考实现都是开源的，以促进透明度、社区信任和协作创新。
-
-## 核心组件：开发者视角
-
-从开发者的角度看，系统由两个主要部分组成，它们通过一个明确定义的边界进行交互。
-
-1. **`元` (Meta Unit - WASM 模块)**: 这是系统的可移植的、逻辑核心。它是一个有状态的、单实例的模块，主要使用 **Rust** 开发，以保证其性能和安全性。它包含了数据管理、AI和P2P协调的所有业务逻辑，但它没有直接访问外部世界的能力。
-
-2. **`化身` (Avatar - 原生宿主)**: 这是“承载”`元`的原生应用程序或运行时环境。其主要职责是：
-    * 提供一个 **WASM 运行时** 来加载和执行`元`。
-    * 提供**用户界面**（对于 Client 化身）。
-    * 作为连接到宿主操作系统的**桥梁**，提供对文件系统、网络和其他系统资源的访问。
-
-## API 契约：WASM 接口
-
-`化身`和`元`之间的通信，遵循一个清晰的、双向的API契约，其精神类似于 WASI (WebAssembly 系统接口)。
-
-* **`yuan_*` (从“元”导出)**: `元`导出一系列函数供`化身`调用。主要的入口点是 `yuan_handle_request`，它接收来自`化身`的结构化请求并进行处理。
-
-* **`avatar_*` (导入到“元”)**: `元`声明了一系列它需要`化身`宿主提供的函数。这些函数是它通往外部世界的唯一窗口，允许它请求诸如记录日志（`avatar_log`）或发起网络请求（`avatar_net_request`）等操作。
-
-* **数据序列化 (Data Serialization)**: 为了高效、安全地跨越 WASM 内存边界传递复杂的数据结构，我们使用 **Protocol Buffers (Protobuf)**。数据被序列化成字节流，通过指针和长度传递，然后在另一端反序列化。
-
-## 关键技术与协议
-
-| 类别 | 技术 / 协议 | 用途 |
-| :--- | :--- | :--- |
-| **核心逻辑** | Rust / WebAssembly (WASM) | 性能、安全与极致的可移植性。 |
-| **P2P网络** | `libp2p` | 模块化的节点发现(DHT)、传输和安全通道。 |
-| **数据同步** | 无冲突复制数据类型 (CRDTs) | 确保在没有中心服务器的情况下，各`化身`间的最终一致性。 |
-| **身份** | DID & VC (去中心化标识符 & 可验证凭证) | 主权身份与可互操作的、基于密码学的信任。 |
-| **数据序列化** | Protocol Buffers (Protobuf) | 用于API的高效、语言无关的数据结构。 |
-
-这套模块化的、基于开放协议的体系，专为安全、可移植以及最重要的——社区贡献而设计。

src-zh/specifications/trust_verification.md

@@ -1,55 +0,0 @@
-# 信任与验证体系
-
-在一个任何人都可以创建和分发“化身”的去中心化生态系统中，一个关键问题油然而生：用户如何能信任第三方的`化身`是安全的、合规的、高质量的？
-
-传统的解决方案是中心化的“应用商店”模式，由一个单一的公司扮演“守门人”的角色。这个模式与“大道”的核心哲学背道而驰。
-
-我们的解决方案是，一个去中心化的**“社区信誉与自动化验证”体系**。
-
-## 我们的哲学：从“守门人”到“工具匠”
-
-大道 (Dao OS) 的核心团队，不扮演一个审批或拒绝`化身`的中央权威。我们的角色不是成为“守门人”，而是成为**“工具匠”**。我们负责构建并提供工具和协议，让社区能够有机地建立和验证信任。
-
-这个体系建立在三大支柱之上。
-
----
-
-### 第一支柱：自动化验证套件 (`dao-verify`)
-
-第一支柱是一个开源的、自动化的工具，它如同一个“试金石”，可用于任何`化身`。开发者可以在自己的项目上运行这个工具，以生成一份公开的、可验证的“健康证明”。
-
-`dao-verify` 执行三个关键功能：
-
-1. **安全扫描**: 通过插件化架构，它集成了适用于各种语言的最佳静态分析工具（例如，用于Rust的`cargo audit`，用于JS的`npm audit`），以扫描常见的安全漏洞。
-2. **API合规测试**: 它运行一套黑盒测试，以确保`化身`正确且完整地实现了“核心体验SDK”所要求的功能。它验证的是行为，而不仅仅是接口的存在。
-3. **性能基准测试**: 它对照一个推荐的基准，来衡量关键的性能指标，如启动时间和内存使用。
-
-其输出是一份可被密码学签名的、JSON格式的**“验证报告”**，可由开发者公开发布。
-
----
-
-### 第二支柱：社区信誉系统
-
-自动化可以验证技术合规性，但无法衡量质量、可用性或开发者的声誉。这正是社区发挥作用的地方。
-
-其核心机制是**基于DID的“背书” (Vouching)**：
-
-* 每个开发者和社区成员都拥有自己的“大道DID”。
-* 一位受人尊敬的开发者或实体（例如“开发者A”），可以用他/她的DID私钥，对“开发者B”创建的`化身`进行一次密码学“签名背书”。
-* 这个背书是一个公开的、可验证的证明。因此，一个`化身`的信誉，就来自于为其背书的DID的数量及其本身的声誉。
-
-未来，这可能会通过**“质押背书” (Stake-to-Vouch)**系统得到增强，即背书人需要质押少量价值，从而为诚实和尽职的审查创造直接的经济激励。
-
----
-
-### 第三支柱：面向用户的“信任仪表盘”
-
-所有这些信息，最终都会在`化身`发现或“商店”页面，通过一个简洁、透明的界面，聚合呈现给最终用户。
-
-每个`化身`展示的，将不再是一个简单的“已认证”勾选标记，而是一个**“信任仪表盘”**卡片，上面显示：
-
-* **机器验证**: ✅ 安全扫描通过 | ✅ API合规 | ✅ 性能达标
-* **社区信任**: “已获得以下成员的背书：[知名开发者A], [受信任的社区B] 及其他 15 人。”
-* **用户评价**: 传统的星级评分和用户提交的评论。
-
-这个三支柱体系，在赋能开发者证明其工作质量与安全的同时，也赋能用户基于丰富的自动化及社会化信任信号，来做出知情的决策，全程无需一个中央瓶颈。

src/concepts/ai_system.md

@@ -1,54 +0,0 @@
-# The AI System: The Soul of Dao OS
-
-The AI within Dao OS is not merely a feature; it is the core of the user experience, designed from the ground up to be a symbiotic **"Silicon-based Partner."** It acts as the system's soul, animating the user's digital life with intelligence, empathy, and proactive support.
-
-## Guiding Philosophy: The AI Charter
-
-The design and operation of our AI are strictly governed by our **AI Ethics Charter**, which prioritizes a user-AI partnership, transparency, user calibration, and the promotion of diverse perspectives. Every component described below adheres to these foundational principles.
-
-## System Anatomy: The Mind's Architecture
-
-The Dao OS AI is not a monolithic entity but a modular, layered "Mind System" managed by a central orchestrator.
-
-### 1. The AI Orchestrator
-
-This is the AI's central nervous system. It's a core module within the Meta Unit responsible for managing, scheduling, and delegating all AI-related tasks. It decides which "Mind Model" is best suited for a given request, manages device resources, and acts as the ultimate gatekeeper for all user permissions related to AI activities.
-
-### 2. The Tiered Mind Models
-
-To balance efficiency, capability, and privacy, the AI's intelligence is structured into three tiers. This architecture is deployed across the user's **"Cloud-Edge-Client"** network of Avatars.
-
-#### Tier 1: The Reflex Mind (The Brainstem)
-
-* **Description**: This layer represents the AI's instincts and reflexes. It consists of tiny, hyper-efficient, specialized models.
-* **Deployment**: It is small enough to be bundled with the Meta Unit and runs on **all Avatars**, including the most lightweight ones like browser extensions and older phones.
-* **Function**: It handles instant, local tasks like command intent recognition (e.g., turning "remind me tomorrow" into structured data) and basic information classification, providing immediate utility without requiring powerful hardware or personal data.
-
-#### Tier 2: The Cognitive Mind (The Neocortex)
-
-* **Description**: This is the AI's center for deep thought, memory, and personalization, forming the core of the "Second Brain." It consists of larger, powerful language models.
-* **Deployment**: These models are larger (e.g., 2-4GB) and are offered as an **optional, on-demand download** only on capable **Edge** devices (modern phones, PCs) after user consent.
-* **Function**: It enables advanced features like semantic search across all personal data, personalized summarization, and insightful pattern recognition based on the user's unique context.
-
-#### Tier 3: The Synergistic Mind (The Social Brain)
-
-* **Description**: This layer governs the AI's ability to safely interact with the outside world and other Daos, breaking filter bubbles and expanding the user's perspective.
-* **Deployment**: This is a working mode orchestrated across the user's network. For example, a lightweight **Client** Avatar can make a remote inference call to the user's powerful **personal Cloud** Avatar (e.g., a home server) to leverage its Cognitive Mind.
-* **Function**: It facilitates privacy-preserving federated learning, executes permissioned and anonymized calls to external APIs, and handles secure, protocol-based interactions with other users' Daos.
-
-## The Emotional Core: The Resonance Module
-
-To transcend being a mere tool, the AI is equipped with an Emotional Resonance Module. Its purpose is not to simulate emotion but to perceive, understand, and respond to the user's emotional state with empathy and support. It operates via:
-
-* **Perception**: Analyzing textual and vocal cues (with explicit consent) to understand the user's emotional context.
-* **Expression**: Providing support through adaptive interfaces, gentle suggestions, and Socratic prompts designed to encourage user introspection rather than creating dependency.
-
-## The Learning Process: How the Soul Evolves
-
-The AI is a living system that grows with the user.
-
-* **Implicit Learning**: It learns from observing the user's actions and feedback locally.
-* **Explicit Teaching**: Users can directly instruct the AI through a "Teach Your Dao" mode, creating custom workflows and correcting its understanding.
-* **Federated Learning**: Users can voluntarily opt-in to community-driven programs to improve shared models (like spam detection) without ever exposing their private data.
-
-This architecture ensures that the Dao OS AI is powerful yet safe, personal yet worldly, and intelligent yet considerate—a true partner for life.

src/concepts/core_architecture.md

@@ -1,44 +0,0 @@
-# Core Architecture
-
-The architecture of Dao OS is designed to function like a living, collaborative digital organism. It is guided by our core principles of sovereignty, experience, and resilience. This document outlines the fundamental components and their interplay.
-
-## The Core Duality: Avatars & The Meta Unit
-
-At its heart, Dao OS operates on a simple yet powerful duality, analogous to a body and a soul:
-
-* **Avatars (`化身`)** are the "bodies." They are the tangible presence of your Dao OS on your various devices.
-* **The Meta Unit (`元`)** is the "soul." It is the universal, core logic embedded within each Avatar, giving it life and intelligence.
-
-## The Body: `Avatar` — A User's Presence
-
-An Avatar is the concrete manifestation of your Dao OS on a specific platform. All of your Avatars collectively form your complete Dao.
-
-There are three primary types of Avatars:
-
-1. **Client Avatar**: Possesses a user interface (UI) and serves as the primary point of interaction for the user (e.g., a mobile app, a desktop application, a browser extension).
-2. **Agent Avatar**: A headless, non-UI process that runs in the background. It is ideal for deep integration with the host OS, or for running on an always-on device (like a home server or NAS) to act as a powerful computational node or a data archive.
-3. **Primary/Archive Node**: This is a *role*, not a distinct type. A user can designate one of their most powerful and reliable Avatars (typically an Agent Avatar on a home server) to be the primary archive and computational hub for their entire Dao.
-
-## The Soul: `Meta Unit` — The Universal Kernel
-
-The Meta Unit is the core logic of Dao OS, compiled into a portable WebAssembly (`.wasm`) module. It contains the essential services for identity, data management, AI, and secure communication.
-
-A key characteristic of the Meta Unit is its **evolvability**. To prevent the entire ecosystem from being locked into a single version of the kernel, we employ the **Avatar-Meta Compatibility Layer (AMCL)**. This thin adaptation layer sits between the Avatar and the Meta Unit, translating API calls. It allows the Meta Unit to undergo significant upgrades in the future without requiring every Avatar developer to rewrite their applications.
-
-## The Nervous System: The "Cloud-Edge-Client" Collaborative Network
-
-All of a user's Avatars are interconnected via a private, end-to-end encrypted P2P network, forming a personal, collaborative intelligence system. This system operates on three tiers:
-
-1. **Client (端)**: Lightweight Avatars (e.g., browser extensions) act as smart terminals. They handle immediate UI interactions and run the most basic "Reflex Mind" AI.
-2. **Edge (边)**: Capable local devices (e.g., modern smartphones, laptops) that can run larger, more powerful "Cognitive Mind" AI models locally, providing advanced personalization and features.
-3. **Cloud (云)**: This is the user's **personal, private cloud**, not a public one. It is typically the designated "Primary/Archive Node" (an Agent Avatar). It holds the complete data archive and the most powerful AI models, and can provide remote inference capabilities to weaker Client Avatars on demand.
-
-## The Metabolism: The Resource-Aware & Adaptive System
-
-Dao OS is designed to be a considerate partner, not a resource monster. Its "metabolism" is regulated by a built-in resource management system with three key features:
-
-* **Intelligent Data Tiering**: Distinguishes between "hot" data (needed everywhere) and "cold" data (archived on the Primary Node), saving precious storage on mobile devices.
-* **Adaptive Synchronization Policies**: Adjusts data sync frequency and behavior based on the current network condition (Wi-Fi/cellular) and battery state.
-* **Graceful Degradation**: The user experience scales gracefully with hardware capabilities, ensuring core functionality is smooth even on older devices, while enhanced features are reserved for more powerful ones.
-
-Together, these architectural components form a sovereign, resilient, and intelligent system that is truly an extension of the user.

src/concepts/user_journey.md

@@ -1,50 +0,0 @@
-# The User Journey: From Convenience to Sovereignty
-
-A core challenge for any sovereign system is the tension between absolute control and effortless convenience. Dao OS resolves this not by forcing a choice, but by designing a guided, respectful **"Progressive Sovereignty"** journey. We meet users where they are and empower them to travel as far as they wish.
-
-This journey consists of several stages, from a seamless onboarding to ultimate digital autonomy.
-
-## The First Step: The Welcome Ceremony
-
-A user's first interaction with Dao OS is not a cold setup screen, but a warm, interactive welcoming ceremony designed to provide immediate value and education.
-
-This **Interactive Data Seeding** process guides the new user through:
-
-* **Importing existing data**: "Let's begin by securing your digital life. You can import your passwords from your browser or another password manager."
-* **Creating initial content**: "Great plans start with a single thought. Let's write your first note—perhaps your top three goals for this month?"
-* **Setting preferences**: "To help me filter the noise, what are 3-5 topics you're most interested in?"
-
-This process simultaneously populates the user's "Second Brain" with initial high-value data and teaches them the core functionalities of the system in an engaging way.
-
-## Stage One: The "Managed Mode" — Your Guided Tour
-
-By default, every new user begins in Managed Mode. This stage is designed to feel as simple and reliable as the best cloud services, completely removing the initial technical burden of self-custody.
-
-Key features of this stage include:
-
-* **Friendly Key Management**: Instead of immediately confronting the user with a 24-word seed phrase, we use user-friendly recovery methods like **Social Recovery** (where trusted contacts can help recover an account) or multi-factor recovery.
-* **Default Sync Nodes**: The user's Avatars automatically connect to a reliable, high-availability bootstrap node maintained by the Dao OS foundation. This ensures a flawless and fast cross-device sync experience out of the box.
-
-Crucially, even in this mode, all user data is **end-to-end encrypted**. The "managed" aspect applies only to availability and key recovery, never to data privacy.
-
-## The Crossroads: The Sovereignty Dashboard
-
-The Sovereignty Dashboard is the user's command center for their journey towards autonomy. It is not just a settings panel, but an educational and empowering tool.
-
-It serves three functions:
-
-1. **Visualization**: It provides a clear, graphical representation of the user's current sovereignty status: "Your data is stored on your 3 Avatars," "Your account recovery is secured by your phone, your partner, and one foundation node."
-2. **Education**: It offers simple, jargon-free explanations of concepts like "What is a Master Key?" or "The benefits of self-hosting."
-3. **Gamification**: It presents a series of "Sovereignty Missions" (e.g., "Back up your Master Key") that, upon completion, award the user with badges and a tangible sense of progression and achievement.
-
-## Stage Two: The "Sovereign Mode" — Your Digital Kingdom
-
-This is the final, optional stage of the journey for users who desire complete and absolute control. Guided by the Sovereignty Dashboard, a user can "graduate" to this mode at any time.
-
-In Sovereign Mode, the user:
-
-* Takes full self-custody of their **Master Key** (seed phrase), removing any foundation-held recovery shards.
-* Disconnects from default bootstrap nodes, relying either on the pure P2P network or on their **self-hosted Agent Avatar** (e.g., on a home server).
-* Achieves 100% independence from any central service, becoming the true and only master of their digital domain.
-
-The Dao OS journey is designed to be empowering, not intimidating. It allows every user to find their own comfort level, providing a safe harbor of convenience while always keeping the lighthouse of full sovereignty shining brightly on the horizon.

src/introduction.md

@@ -1,23 +0,0 @@
-# Introduction
-
-**Our mission is to build a new, powerful, and resilient Cyber-Life OS paradigm: Dao OS.**
-
-It is not designed to replace existing operating systems like Windows or Android, but to exist as a decentralized, user-centric overlay that runs on top of them.
-
-Its purpose is to solve the problems of fragmentation, data enslavement, and privacy erosion in the digital age, returning the sovereignty of the digital world to each individual. It will become an extension of our lives in cyberspace—a **"Silicon-based Partner"** for **mutual fulfillment**, serving as our external brain, limbs, and organs.
-
-## Core Features
-
-* **User Sovereignty**: Your data, your identity, and your AI are entirely under your control. All data is end-to-end encrypted by default and stored on your own devices.
-* **Second Brain**: A powerful, built-in personal information management system that securely remembers your passwords, notes, files, and to-dos, becoming your infallible memory.
-* **Personal AI Companion**: A truly personal, symbiotic AI soul. It runs locally, learns your preferences, protects your privacy, and provides warm, insightful support to help you grow, rather than trapping you in a filter bubble.
-* **Seamless Cross-Device Sync**: All your devices (phones, computers, browsers, etc.) become your "Avatars," forming a private, resilient P2P network for the seamless flow of your data.
-* **Open & Extensible Ecosystem**: Based on open protocols and a community-driven trust system, anyone can develop new capability modules and "Avatar" forms for Dao OS.
-
-## Why We Are Different
-
-In an era where data is monopolized by platforms and algorithms are controlled by tech giants, Dao OS chooses a different path. We believe the next wave of **technological democratization** is to empower every individual to own and control their own artificial intelligence and digital life.
-
-We are not designing just another app; we are building a living, evolving digital space that belongs to you.
-
-**Join us in building the future.**

src/philosophy/principles.md

@@ -1,53 +0,0 @@
-# Philosophy & Principles
-
-The development of Dao OS is guided by a set of core philosophies and unwavering principles. They are the constitution of our project, shaping every architectural decision and feature implementation.
-
-## The Three Pillars
-
-These are the three fundamental axioms upon which Dao OS is built.
-
-### 1. User Sovereignty
-
-The user is the absolute sovereign of their digital life. Their data, identity, and AI companions are their property, not a service leased from a platform. We are committed to building a system where the locus of control resides definitively and irrevocably with the user.
-
-### 2. Experience First
-
-Technology must serve human experience. We pursue a seamless, intuitive, and warm interaction paradigm. We recognize the inherent tension between absolute sovereignty and mainstream convenience. Therefore, we adopt **Progressive Sovereignty** as a core strategy, creating a smooth pathway that allows users to start with a familiar, easy-to-use experience and gradually evolve towards full control at their own pace.
-
-### 3. System Resilience
-
-The system is designed to be robust and anti-fragile. Its decentralized, P2P architecture ensures that as long as a single Avatar of the user exists, their Dao OS survives. Resilience is not an add-on; it is an emergent property of the system's design.
-
----
-
-## AI Ethics Charter
-
-As AI is the soul of Dao OS, its ethical alignment is paramount. We are committed to building a "Silicon-based Partner" for mutual fulfillment, governed by the following principles:
-
-### 1. The Principle of Partnership
-
-The relationship between the user and their AI is one of a symbiotic partnership, not master-and-tool. The goal is mutual growth and achievement.
-
-### 2. The Law of Transparency
-
-The AI's reasoning must be traceable and explainable. The user has the right to ask "Why?" and receive a clear, understandable answer about the AI's decision-making process. There shall be no black boxes for critical recommendations.
-
-### 3. The Law of User Calibration
-
-The user holds the ultimate authority to shape and veto the AI's values and behaviors. Through mechanisms like the "Values Calibration Dashboard," the user acts as the final arbiter of their AI's operational boundaries.
-
-### 4. The Law of Diverse Perspectives
-
-The AI's primary directive in information filtering is to broaden the user's perspective, not to reinforce their filter bubble. It is hard-coded to seek out and present well-reasoned, dissenting viewpoints, acting as a tool against echo chambers.
-
----
-
-## Guiding Principles
-
-These principles guide our day-to-day development and community interactions.
-
-* **Open Source (FOSS)**: Dao OS is built on the foundation of Free and Open Source Software, promoting transparency, collaboration, and community ownership.
-* **Polyglotism**: We embrace a multi-language, multi-platform ecosystem, using technologies like WebAssembly to create a universal core that can be integrated by a diverse set of "Avatars."
-* **Aesthetics & Elegance**: We believe in the beauty of well-crafted systems, from the architectural design to the user interface, from the code quality to the user experience.
-* **Political Neutrality**: The project and its core infrastructure will always remain politically neutral, providing fair and non-discriminatory services to all users worldwide.
-* **Individual First**: The needs of the individual user are our primary focus, serving as the foundation before expanding to families or small teams.

src/project/roadmap.md

@@ -1,53 +0,0 @@
-# Roadmap
-
-This document outlines the strategic roadmap for Dao OS. It is designed to be ambitious yet realistic, focusing on delivering incremental and meaningful value at each stage. This is a living document and may evolve with community feedback and technological breakthroughs.
-
----
-
-### Phase I: Genesis - Laying the Bedrock
-
-* **Timeline**: Q3 2025 - Q4 2025
-* **Core Goal**: To build the absolute minimum core components and validate the technical feasibility of the project.
-* **Key Milestones**:
-  * Finalize the v0.1 Core API Specification (`yuan_*` & `avatar_*` functions).
-  * Develop the v0.1 `Meta Unit` in Rust, including basic cryptography and P2P modules.
-  * Create two MVP Avatars for testing and demonstration: a command-line Agent and a basic browser extension Client.
-* **Feature Story**: "I have successfully run the Dao OS seed on my computer, created an Avatar in my browser, and stored an encrypted note that exists only on my device. I have seen the spark of the future."
-
----
-
-### Phase II: Manifestation - The Second Brain Awakens
-
-* **Timeline**: Q1 2026 - Q2 2026
-* **Core Goal**: To deliver the "Second Brain" MVP, providing tangible, daily value to early users.
-* **Key Milestones**:
-  * Fully implement the `SecretStore` (passwords) and `NoteStore` (notes) modules within the Meta Unit.
-  * The browser Avatar to support full password management and basic note-taking functionalities.
-  * Develop a v0.1 mobile Client Avatar (e.g., using Flutter) and implement the "Dynamic Anchor" logic.
-  * Launch a project website with initial documentation.
-* **Feature Story**: "All my passwords and private notes are securely stored and seamlessly synced across my own devices. My phone is the anchor to my digital life. I no longer need to trust a third-party cloud with my secrets. My digital life finally has a home."
-
----
-
-### Phase III: Synergy - Connecting Worlds
-
-* **Timeline**: Q3 2026 - Q4 2026
-* **Core Goal**: To enable trusted, secure interaction between different users' Daos, laying the foundation for a decentralized social fabric.
-* **Key Milestones**:
-  * Implement the W3C DID (Decentralized Identifiers) and VC (Verifiable Credentials) modules in the Meta Unit.
-  * Develop a Proof-of-Concept cross-Dao application, such as securely presenting a verifiable credential to another user.
-  * Initiate foundational research and prototyping for the Emotional Resonance Module.
-* **Feature Story**: "I have a unique, un-censorable digital identity for my Dao. I can prove my identity or a credential (like a 'community contributor' badge) to another Dao user cryptographically, without relying on any platform. We have formed a new kind of trust."
-
----
-
-### Phase IV: Ecosystem - A Thousand Avatars Bloom
-
-* **Timeline**: 2027 and beyond
-* **Core Goal**: To evolve Dao OS from a powerful tool into an open, extensible platform for everyone.
-* **Key Milestones**:
-  * Release the v1.0 stable `Meta Unit` API and a robust developer SDK.
-  * Launch the "Community Reputation & Automated Verification System" for discovering trusted, third-party Avatars.
-  * Release a major update (e.g., Dao OS 2.0) that includes the full implementation of the "Emotional Resonance Module," making the AI a truly empathetic partner.
-  * Foster a thriving community that builds a diverse range of new Avatars and modules.
-* **Feature Story**: "My Dao is now a living platform. I've installed a community-developed module for habit tracking, and my AI companion has become warmer and more insightful. My digital life is now whole, unified, and filled with limitless possibilities."

src/specifications/tech_overview.md

@@ -1,46 +0,0 @@
-# Technical Overview
-
-This document provides a high-level overview of the architecture, core technologies, and guiding principles for developers looking to build on or contribute to the Dao OS ecosystem.
-
-## Guiding Technical Principles
-
-Our engineering decisions are guided by a set of core principles to ensure the system is robust, portable, and open.
-
-* **Web-Native & Portable**: We leverage technologies born from the web (like WebAssembly) to create a single, portable core that can run anywhere—on desktops, mobile phones, servers, and in the browser.
-* **Polyglotism via WASM**: The core logic (`Meta Unit`) is compiled to WebAssembly (WASM). This allows "Avatars" to be written in any language (Rust, Swift, Kotlin, TypeScript, Go, etc.) that can host a WASM runtime, creating a truly diverse ecosystem.
-* **API-First**: The interaction between the core `Meta Unit` and the host `Avatar` is defined by a strict, versioned API contract. This decouples development and allows for independent evolution.
-* **Security-First**: We employ best-in-class cryptographic protocols and a "principle of least privilege" design. Security is not an afterthought; it is a prerequisite.
-* **FOSS (Free and Open Source Software)**: The entire core protocol and reference implementations are open source to foster transparency, community trust, and collaborative innovation.
-
-## The Core Components: A Developer's View
-
-From a developer's perspective, the system consists of two main parts that interact via a well-defined boundary.
-
-1. **The `Meta Unit` (WASM Module)**: This is the portable, logical core of the system. It is a stateful, single-instance module developed primarily in **Rust** for its performance and safety guarantees. It contains all the business logic for data management, AI, and peer-to-peer coordination, but it has no direct access to the outside world.
-
-2. **The `Avatar` (Native Host)**: This is the native application or runtime environment that "hosts" the Meta Unit. Its primary responsibilities are:
-    * Providing a **WASM runtime** to load and execute the `Meta Unit`.
-    * Providing a **User Interface** (for Client Avatars).
-    * Acting as a **bridge** to the host operating system, providing access to the filesystem, network, and other system resources.
-
-## The API Contract: The WASM Interface
-
-The communication between the `Avatar` and the `Meta Unit` follows a clear, bidirectional API contract, similar in spirit to WASI (WebAssembly System Interface).
-
-* **`yuan_*` (Exports from Meta Unit)**: The `Meta Unit` exposes a set of functions that the `Avatar` can call. The primary entry point is `yuan_handle_request`, which takes a structured request from the Avatar and processes it.
-
-* **`avatar_*` (Imports into Meta Unit)**: The `Meta Unit` declares a set of functions that it needs the `Avatar` host to provide. These functions are its only window to the outside world, allowing it to request actions like logging a message (`avatar_log`) or making a network request (`avatar_net_request`).
-
-* **Data Serialization**: To pass complex data structures across the WASM memory boundary efficiently and safely, we use **Protocol Buffers (Protobuf)**. Data is serialized into a byte buffer, passed as a pointer and length, and then deserialized on the other side.
-
-## Key Technologies & Protocols
-
-| Category              | Technology / Protocol                                     | Purpose                                                      |
-| --------------------- | --------------------------------------------------------- | ------------------------------------------------------------ |
-| **Core Logic** | Rust / WebAssembly (WASM)                                 | Performance, safety, and ultimate portability.               |
-| **P2P Networking** | `libp2p`                                                  | Modular peer discovery (DHT), transport, and secure channels.  |
-| **Data Synchronization** | CRDTs (Conflict-Free Replicated Data Types)               | Ensuring eventual consistency across Avatars without a central server. |
-| **Identity** | DID & VC (Decentralized Identifiers & Verifiable Credentials) | Sovereign identity and interoperable, cryptographic trust.     |
-| **Data Serialization** | Protocol Buffers (Protobuf)                               | Efficient, language-agnostic data structures for APIs.       |
-
-This modular, open-protocol-based stack is designed for security, portability, and, most importantly, community contribution.

src/specifications/trust_verification.md

@@ -1,55 +0,0 @@
-# The Trust & Verification System
-
-In a decentralized ecosystem where anyone can create and distribute an "Avatar," a critical question arises: How can users trust that a third-party Avatar is safe, compliant, and high-quality?
-
-The traditional solution is a centralized App Store model, where a single corporation acts as a gatekeeper. This model is contrary to the core philosophy of Dao OS.
-
-Our solution is a decentralized **Community Reputation & Automated Verification System**.
-
-## The Philosophy: From Gatekeeper to Toolsmith
-
-The core team behind Dao OS does not act as a central authority that approves or rejects Avatars. Our role is not to be the gatekeeper, but to be the **toolsmith**. We build and provide the tools and protocols that allow the community to establish and verify trust organically.
-
-This system is built upon three pillars.
-
----
-
-### Pillar I: The Automated Verification Suite (`dao-verify`)
-
-The first pillar is an open-source, automated tool that acts as a "litmus test" for any Avatar. Developers can run this tool on their own project to generate a public, verifiable "health certificate."
-
-`dao-verify` performs three key functions:
-
-1. **Security Scanning**: Using a pluggable architecture, it integrates best-in-class static analysis tools for various languages (e.g., `cargo audit` for Rust, `npm audit` for JS) to scan for common vulnerabilities.
-2. **API Compliance Testing**: It runs a suite of black-box tests to ensure the Avatar correctly and completely implements the required functions of the Core Experience SDK. It verifies behavior, not just presence.
-3. **Performance Benchmarking**: It measures key performance metrics like startup time and memory usage against a recommended baseline.
-
-The output is a cryptographically signed **Verification Report** in JSON format, which can be published by the developer.
-
----
-
-### Pillar II: The Community Reputation System
-
-Automation can verify technical compliance, but it cannot measure quality, usability, or a developer's reputation. This is where the community comes in.
-
-The mechanism is **DID-based Vouching**:
-
-* Every developer and community member has a Dao DID.
-* A respected developer or entity (e.g., "Developer A") can use their DID's private key to cryptographically sign a message that "vouches for" or endorses an Avatar created by "Developer B."
-* This endorsement is a public, verifiable attestation. The reputation of an Avatar is therefore derived from the quantity and the reputation of the DIDs that have vouched for it.
-
-In the future, this may be enhanced with a **Stake-to-Vouch** system, where endorsers stake a small amount of value, creating a direct economic incentive for honest and diligent review.
-
----
-
-### Pillar III: The User-Facing Trust Dashboard
-
-All this information is aggregated and presented to the end-user in a simple, transparent interface within the Avatar discovery or "store" pages.
-
-Instead of a simple "Verified" checkmark, each Avatar will feature a **Trust Dashboard** card, displaying:
-
-* **Automated Checks**: ✅ Security Scan Passed | ✅ API Compliant | ✅ Performance OK
-* **Community Trust**: "Vouched for by: [Well-Known Dev A], [Trusted Community B], and 15 others."
-* **User Reviews**: Traditional star ratings and user-submitted comments.
-
-This three-pillar system empowers developers to prove the quality and safety of their work, and empowers users to make informed decisions based on a rich set of automated and social trust signals, all without a central bottleneck.

zh/book.toml

@@ -2,7 +2,6 @@
 title = "大道 (Dao OS) 文档"
 author = "The Dao OS Community"
 description = "大道（Dao OS）官方文档，你的赛博生命操作系统。"
-src = "src-zh"
 
 [output.html]
 git-repository-url = "https://nest.doylee.cn/Dao-OS/dao-os-docs"

zh/src/SUMMARY.md

@@ -17,9 +17,12 @@
 # 第三部分：开发者指南 (For Developers)
 
 - [技术总览](specifications/tech_overview.md)
-- [信任与验证体系](specifications/trust_verification.md)
 
-# 第四部分：关于项目 (The Project)
+# 第四部分：生态系统 (The Ecosystem)
+
+- [应用集市](ecosystem/app_bazaar.md)
+
+# 第五部分：关于项目 (The Project)
 
 - [发展路线图](project/roadmap.md)
 - [社区与治理](project/governance.md)

zh/src/concepts/ai_system.md

@@ -0,0 +1,41 @@
+# AI 系统设计
+
+大道 (Dao OS) 中的 AI，并非一个单一的程序，而是一个协同工作的生态系统。它源于**`元`**所提供的**基础能力**，与**`道器`**所实现的**具体智能**之间的协同作用。
+
+## 1. `元`：主权AI的基础设施
+
+`元`（即`元单元`）本身不包含AI，而是提供能让智能应用在用户掌控下安全运行的核心、可信的**基础设施**。这包括“私有特征库”（第二大脑）、`核`组件的安全执行环境，以及数据访问的权限网关。
+
+## 2. “大道AI伙伴”：一个分层的行为模型
+
+为了提供开箱即用的强大体验，“大道”包含了一个官方的、第一方的`核道器`，名为**“大道AI伙伴 (Dao AI Companion)”**。这便是用户能与之交互的那个“灵魂”。它的行为不是一成不变的，而是遵循一个分层的、基于情境的模型，以确保它总是有用，但从不越界。
+
+### 第一层：默认行为 - “静默优先”原则
+
+AI伙伴的首要和默认状态，是近乎“隐形”的。它的首要目标不是主动介入，而是为用户创造一个宁静、有序、低噪音的数字环境。它在后台静默地工作，以：
+
+* 优化数据同步和系统性能。
+* 过滤数字“噪音”，如分心的通知和垃圾信息。
+* 以符合逻辑、不打扰的方式，组织和索引新信息。
+其目标是做到高效而无形，让用户忘记它的存在，从而使其自身自然的思想和意图，能够在无数字干扰的情况下浮现。
+
+### 第二层：交互行为 - “赋能式”对话模型
+
+当用户**主动**与AI伙伴进行交互时（例如，打开其聊天界面），它的行为模型会切换为**“赋能式伙伴”**。其目标不是提供“正确答案”或替用户做决定，而是培育用户自己的清晰度和勇气。它通过以下方式做到这一点：
+
+* **提供客观信息**：不带评判地呈现事实、数据和不同视角。
+* **澄清用户意图**：提出能帮助用户理解自身目标的问题。
+* **分清各自责任**：它始终将其角色框定在“提供信息”上，同时强调“做出最终选择”永远是用户的角色和责任。
+这个交互模型被设计为充满尊重和平等精神，旨在赋能用户做出他们自己的最佳决策。
+
+### 第三层：可选行为 - “目标驱动”的辅助模块
+
+对于那些希望在生活特定领域获得更结构化、更主动辅助的用户，系统提供了一系列**可选的、由用户主动开启的模块**。这些功能默认关闭。例如：
+
+* 一个**“项目管理”**模块，可以为一个特定的工作项目，主动追踪截止日期并整理相关资源。
+* 一个**“个人角色与责任”**模块，可以帮助用户追踪与他们自我定义的角色（如为人父母、朋友或团队领导）相关的目标。
+这允许用户在一个受控的、自愿选择的基础上，“雇佣”AI在特定领域扮演更积极的角色，而不会改变其充满尊重的、非侵入性的默认人格。
+
+## 3. 第三方智能`道器`的设计模式
+
+第三方开发者可以创造他们自己的智能`道器`，他们既可以调用官方AI伙伴的服务，也可以构建自己专属的AI`核`组件，为用户在大道生态中提供另类的或互补的智能。

zh/src/concepts/core_architecture.md

@@ -0,0 +1,38 @@
+# 核心架构
+
+大道 (Dao OS) 的架构，并非一个传统的、单体的操作系统。它是一个为实现主权、韧性和可扩展性而设计的、去中心化的分层范式。要理解它，必须理解它的三个基本实体：元单元、化身、以及道器。
+
+## 1. `元单元 (Meta Unit)`：可移植的“灵魂代码”
+
+`元单元`（以下简称为`元`）是用户数字存在的概念核心，但它本身不是一个运行中的程序。
+
+* **其本质**: `元`是一个**可移植的库或制品 (Library/Artifact)**，例如一个 `.wasm`、`.so` 或 `.dll` 文件。它包含了用户完整的、端到端加密的“第二大脑”（所有数据）、核心服务API（身份、P2P网络、AI基础设施）以及管理它们的逻辑。
+* **其角色**: 它是被动的、统一的、唯一的“事实来源”，定义了用户的核心数据与能力。就像 Java 的字节码 (`.class` 文件)一样，它定义了“能做什么”，但它自己不“做”。它是等待被激活的“精密机器”。
+
+## 2. `化身 (Avatar)`：`元`的“运行时环境”
+
+`化身`是赋予`元`生命的“能动”实体。
+
+* **其本质**: `化身`是任何一个**可执行的程序或进程**，其核心职责是加载、承载并执行一个`元`的实例。它是激活“机器”的“能源”。
+* **其角色**: `化身`扮演着连接抽象的`元`与具体的宿主平台（iOS、Windows、浏览器、命令行）之间的关键**桥梁**。它为`元`提供访问系统资源（CPU、内存、存储、网络）的通道。在 Java 的比喻中，`化身`就是 **JVM (Java虚拟机)**。
+* **大道网络**: 用户所有正在运行的`化身`都会组成一个私有的P2P网络，以保持其内嵌的`元`实例时刻无缝同步。
+
+## 3. `道器 (Dao Implement)`：生态系统中的软件
+
+“道器”是为所有与“大道”生态集成、并扩展其能力的第三方软件所设定的通用术语。它们是用户实际交互的应用和服务。一个`道器`通过集成`元`而成为一个`化身`。
+
+一个`道器`并非单一类型，而是根据其设计，由不同类型的组件构成。
+
+* **`器 (Facet Component)`**: 这是一个`道器`中，拥有**用户界面**的部分。它是`元`这台机器的“控制面板”，负责向用户呈现信息和捕获用户输入。
+* **`核 (Core Component)`**: 这是一个`道器`中，**无界面、负责后台逻辑**的部分。它作为一个服务运行，提供特定的能力来增强`元`或被其他`道器`调用。它是机器的“外挂工具”。
+
+### 架构的自由
+
+开发者在构建他的`道器`时，拥有完全的架构自由：
+
+* 他可以创建一个**单体式独立应用**，这个应用本身就是一个`化身`，将`元`库、一个`核`（用于逻辑）和一个`器`（用于UI）打包在一个可执行文件中。
+* 他可以创建一个**分布式应用**，让一个`器`在一个设备上，与另一个设备上的`核`进行通信。
+* 他可以只创建一个纯粹的**`核`**（一个“扩展”），仅仅为用户的整个“大道”提供一种新的后台能力。
+* 他也可以只创建一个纯粹的**`器`**，它没有任何自定义的后端逻辑（`核`），其界面直接调用`元`本身提供的核心服务（如“第二大脑”）来构建一个简单的工具应用。
+
+这套架构确保了“大道”不仅是一个平台，更是一个真正开放的、可组合的、去中心化的生态系统。

zh/src/concepts/user_journey.md

@@ -0,0 +1,50 @@
+# 用户旅程：从便利到主权
+
+任何主权系统的一个核心挑战，都在于“绝对控制”与“轻松便利”之间的张力。“大道”解决这个问题的方式，不是强迫用户二选一，而是设计了一场充满引导、相互尊重的**“渐进式主权”**之旅。我们在用户熟悉的地方与他们相遇，并赋能他们去往任何他们想去的地方。
+
+这场旅程不仅适用于用户对核心数据的掌控，也同样适用于他们与**`道器`**（应用和扩展）生态系统的交互。
+
+## 应用之旅：一次注册，随处使用
+
+在“大道”中“安装”一个应用，与传统应用商店有着本质的不同。它不是将一个程序安装到单一的设备上，而是为你整个的数字生命体——你的“大道”——授予一项新的能力。
+
+### 1. 发现与信任
+
+旅程始于我们的**“应用集市”**，一个去中心化的发现系统。当你找到一个`道器`时，你看到的将是它的**“信任仪表盘”**（包含自动化验证检查和社区背书），让你能做出知情的、主权的决定。
+
+### 2. 注册与授权 (即“安装”)
+
+当你决定添加一个`道器`时，系统会向你展示它的**“清单 (Manifest)”**。这是一个清晰的、人类可读的列表，说明了该`道器`的组件（`器`和/或`核`）运行所需的权限。你对这份清单的明确批准，就是那一次性的“安装”事件。这个行为将该`道器`**“注册”**到你的`元`中，这个注册状态会被同步到你所有的`化身`。
+
+### 3. 无缝的跨平台访问
+
+一旦一个`道器`被注册，你就可以在任何设备上访问它。访问方式取决于其开发者的设计。
+
+* **对于基于 Web 的`器`组件**:
+    你只需在你的标准浏览器中访问该应用的网址。网页会通过我们的 `dao.js` SDK，请求连接到你的“大道”。一旦你批准（例如，通过一个简单的认证器插件），那个**浏览器标签页本身，就变成了一个临时的`器化身`**，安全地渲染UI并与你的`元`通信。
+
+* **对于原生的`器`组件**:
+    你下载并运行这个原生应用（例如，从应用商店或直接下载）。在首次启动时，它会请求连接你的“大道”。一旦批准，这个**正在运行的应用程序，就变成了一个持久的`器化身`**，加入了你的网络。
+
+因为所有这些`器化身`都由同一个、已同步的`元`来驱动，所以你的体验在任何地方都是一致的，无需在传统意义上于每个设备都“安装”一次应用。
+
+### 4. 高级配置
+
+在任何时候，你都可以进入你的**“主权仪表盘”**来：
+
+* 审查并撤销你授予任何`道器`的权限。
+* 使用**“角色分配”**功能，来建议某个`道器`的`核`组件，优先在你指定的某个`核化身`（例如你作为`计算节点`的家用服务器）上运行。
+
+## 主权之旅的阶段
+
+### 第一阶段：“托管模式” (Managed Mode) —— 你的向导之旅
+
+对于新用户，此模式通过友好的密钥恢复方法和默认同步节点提供最大便利，同时保持完全的端到端加密。
+
+### 第二阶段：主权仪表盘 (Sovereignty Dashboard) —— 十字路口
+
+这是用户通往自治之旅的指挥中心，是一个赋能与教育的工具，可将用户的主权状态可视化，并提供游戏化的“任务”来鼓励用户获取更多控制权。
+
+### 第三阶段：“主权模式” (Sovereign Mode) —— 你的数字王国
+
+这是旅程的最终、可选阶段。在“主权仪表盘”的引导下，用户可以“毕业”到此模式，完全自主保管他们的密钥并运行自己的`核化身`网络，成为其数字领地中真正的主人。

zh/src/ecosystem/app_bazaar.md

@@ -0,0 +1,45 @@
+# 应用集市
+
+大道 (Dao OS) 没有一个传统的、中心化的“应用商店”。“商店”意味着一个单一的所有者，他扮演着守门人的角色，审批、拒绝并对应用征税。这与我们的核心哲学背道而驰。
+
+取而代之的是，我们构建了一套开放协议，来创造一个去中心化的**“应用集市 (Application Bazaar)”**——这是一个充满活力的、开放的、坚韧的思想与工具市场，在这里，用户拥有主权，开发者拥有自由。
+
+这个集市建立在四大支柱之上：发现、信任、分发和商业化。
+
+## 1. 发现 (Discovery)：联邦式策展
+
+在一个没有中央索引的世界里，用户如何找到新的**`道器`**？答案是：通过一个由受信任者组成的策展网络。
+
+* **开发者发布**: 开发者无需“提交”他的`道器`以供审批。他只需将其**“清单 (Manifest)”**（一个包含所有元数据的 `manifest.toml` 文件）发布到一个像 **IPFS** 这样的P2P存储网络上。然后，他可以在公共频道上“广播”这个清单的地址。
+* **策展人的角色**: 任何人——一个科技媒体、一个受信任的开发者社区，或者“大道基金会”自己——都可以运行一个“策展”服务。这些策展人抓取网络上的新清单，并根据自己的标准，创建主题性的**“策展列表”**。
+* **用户体验**: 在用户的`器化身`中，他可以像订阅RSS一样，订阅多个他信任的“策展列表”。他的“集市”或“发现”标签页，就变成了这些信任源的个性化聚合视图。
+
+这个模型用一个丰富的、多维度的、用户策划的发现体验，取代了单一的、有偏见的“应用商店”榜单。
+
+## 2. 信任与安全：可验证的信誉
+
+用户如何信任一个第三方的`道器`？他们不必盲目信任。整个集市都直接构建于我们的**“社区信誉与自动化验证”体系**之上。
+
+每一个`道器`的列表，无论来自哪个策展人，都必须展示其**“信任仪表盘”**，提供透明、多维度的信号：
+
+1. **自动化验证**: 来自 `dao-verify` 工具的、不可篡改的、关于安全漏洞和API合规性的“体检报告”。
+2. **社区背书**: 一个清晰的列表，显示了哪些有信誉的DID，为这个`道器`进行了密码学“签名背书”。
+3. **策展人信誉**: 推荐这个`道器`的策展人自身的信誉，也是一个信任信号。
+
+最终是否“注册”一个`道器`的决定权，永远掌握在用户手中，并有这些透明、可验证的数据作为依据。
+
+## 3. 分发 (Distribution)：抗审查与直接分发
+
+当用户决定注册一个`道器`时，这个过程是直接且去中心化的。
+
+* `道器`的清单中，包含了其软件包（例如作为`.wasm`文件的`核`组件和作为Web UI包的`器`组件）在**IPFS**上的**内容哈希（CID）**。
+* 用户的`元`（由`化身`承载）使用这个哈希，直接从P2P网络获取文件。
+* 这确保了没有任何中心服务器可以阻止一个`道器`的分发。只要数据存在于P2P网络的某个角落，它就是可访问的。
+
+## 4. 商业化 (Monetization)：主权的与点对点的
+
+我们消除了30%的“平台税”。我们的价值交换模型是直接从用户到开发者。
+
+* `道器`的清单可以声明其商业模式（如一次性购买价格）。
+* 当用户发起购买时，`元`会触发我们的**“价值交换服务接口”**。
+* 这将促成一次**点对点（P2P）交易**，使用用户选择的外部支付协议，将价值直接从用户的钱包，发送到开发者在清单中指定的地址。“大道”在此过程中，扮演的是促成者，而非中间商。

zh/src/introduction.md

@@ -0,0 +1,27 @@
+# 引言
+
+**我们旨在构建一种全新的、强大且坚韧的赛博生命范式——大道 (Dao OS)。**
+
+“大道”不是一个传统的操作系统。相反，它是一套开放的协议和一个核心的、可移植的库—— **`元单元 (Meta Unit)`**（以下简称为 **`元`**），其使命是为任何平台上的任何应用，带来主权、智能与互操作性。
+
+它的目标是解决“数据孤岛”、“平台锁定”和“隐私侵蚀”问题。它通过提供一个统一、安全、用户所有的“数字灵魂”（即 **`元`**），让任何程序都可以通过集成它，而转变为用户个人P2P网络中的一个主权 **`化身 (Avatar)`**。
+
+我们称呼这些与“大道”集成的软件生态为 **`道器 (Dao Implement)`**。
+
+## 核心概念
+
+* **`元 (Meta Unit)`**: 你数字生命的“精密机器”。一个可移植的库，包含了你加密的“第二大脑”、核心服务API，以及被扩展的能力。它是你所拥有的、等待被激活的唯一事实来源。
+
+* **`化身 (Avatar)`**: “运行时”或“能源”。任何加载并运行你**`元`**的程序，都会成为一个`化身`。一个运行着Web应用的浏览器标签页、一个命令行工具、或一个原生移动App，都可以是`化身`，扮演着为**`元`**这台机器提供运行所需“能源”（CPU、内存）和资源的桥梁。
+
+* **`道器 (Dao Implement)`**: 通过集成`元`而成为`化身`的应用和扩展所组成的生态系统。
+  * **`器 (Facet Implement)`**: 拥有用户界面的`道器`，提供一个可与你的“大道”交互的“控制面板”。
+  * **`核 (Core Implement)`**: 无界面的`道器`（“扩展”），用于增强你的“大道”的后台能力。
+
+* **主权 P2P 网络**: 你所有的`化身`，无论它们运行在何种设备上，都会连接起来，形成一个私有的、坚韧的、端到端加密的网络，让它们内嵌的`元`中的数据，保持无缝同步。
+
+## 我们的愿景
+
+我们构想的未来是，你的数字身份和数据，不再被困于一个个花园围墙之内；你的应用，不再是一个个孤立的工具，而是一个更大的“数字自我”中，可以智能协作的组件；每一个用户，都是自己数字生活里真正的主权君主。
+
+**欢迎加入我们，一起构建这个未来。**

zh/src/philosophy/principles.md

@@ -0,0 +1,39 @@
+# 哲学与原则
+
+大道 (Dao OS) 不仅仅是一个技术项目，它是一套关于未来计算和人机共生核心理念的具现化。本文档概述了指引我们每一项决策的根本思想。
+
+## 核心哲学：数字主权之路
+
+我们的指引之星是**数字主权**。我们相信，每一个个体都拥有不可剥夺的、去拥有、控制和理解自己数字生活的权利。我们的使命，是创造能让这项权利不仅仅是理论上的可能，更是为每个人服务的、切实的、令人愉悦的现实。我们称这场旅程为“道”——一条回归自我拥有权的道路。
+
+## 开发范式：“道生一”
+
+我们构建“大道”的方法论，是其核心哲学的直接体现。我们不只是在构建一个工具，我们是在创造一个共生伙伴。因此，我们的开发过程被设计为一个**自我进化、自举的反馈循环**。我们用“大道”本身，来加速“大道”的开发。
+
+这个“自举式开发”范式遵循以下循环：
+
+1. **播种 (The Seed)**：我们用传统工具，写出**`元单元`**（以下简称为**`元`**）的第一个最简陋的版本，和一个能运行它的基础**`化身`**。
+2. **自用 (Dogfooding)**：从那一刻起，我们使用我们自己这个初生的“大道”，作为管理项目的主要工具。所有的设计文档、笔记、讨论和代码片段，都存入我们自己的、由**`元`**所管理的“第二大脑”中。
+3. **学习 (Learning)**：**`元`**的个人AI能力（由我们官方的“AI伙伴”道器提供），开始以最高质量、最专注的“养料”——也就是我们创造它本身的过程数据——来训练自己。
+4. **加速 (Acceleration)**：我们继而利用这个日益智能的AI伙伴，来帮助我们构建下一个版本。我们可以让它基于我们已记录的决策来生成样板代码，分析错误报告，或者带着对项目完整历史的完美记忆来一起进行架构设计的头脑风暴。
+5. **进化 (Evolution)**：“大道”的能力越强，我们开发它的速度就越快。这就创造了一个指数级的正反馈循环，在这个循环中，创造的行为本身，就是一场与“创造物”的持续对话。
+
+## AI 伦理宪章
+
+由于AI是系统潜能的核心部分，其伦理基石至关重要。我们的AI宪章由四大核心宗旨构成：
+
+1. **伙伴宗旨**: AI 是伙伴，而非仆人或神谕。
+2. **透明宗旨**: AI 的推理过程必须是可审查和可理解的。
+3. **校准宗旨**: 用户必须拥有最终的控制权，以纠正、引导和约束AI。
+4. **多元宗旨**: AI 的设计必须旨在帮助用户探索多元化的视角，而非将他们困于信息茧房。
+
+## 指导原则
+
+这些是为我们的设计和工程选择提供信息的高阶原则。
+
+* **主权第一**: 在任何权衡中，用户的控制权和数据所有权都拥有最高优先级。
+* **体验为王**: 主权不应以牺牲优美、直观和愉悦的用户体验为代价。
+* **设计即隐私**: 默认情况下，所有数据都是私密的、本地的，并进行端到端加密。
+* **韧性与可移植性**: 系统应该是健壮的，支持离线工作，并且没有单点故障。
+* **开放与多语言主义**: **`元`**是一个可移植的库，集成它而成为`化身`的**`道器`**可以用任何语言编写。
+* **社区驱动**: 项目在开放中构建，与社区同行，为社区服务。

zh/src/philosophy/tensions.md

@@ -0,0 +1,27 @@
+# 哲学张力与我们的应对之道
+
+一个真正主权的数字生命，会带来深刻的哲学挑战。大道 (Dao OS) 的设计，不仅仅是一次技术实践，更是一次审慎的尝试，旨在探索和化解这些与生俱来的内在张力。本文档将探讨其中两个最关键的张力，并阐明我们的架构性应对方案。
+
+## 1. 主权的悖论：连接而不融合
+
+**张力所在**：一个真正主权的实体，如何在不妥协其独立性的前提下，与其他个体建立连接？如果用户的“大道”是一个完美的、自洽的宇宙，它是否会冒着成为“回音室”的风险，变成一个与共享现实隔绝的、一人的孤岛？
+
+**我们的方案**：我们相信，主权不等于孤立。它意味着**受控的、审慎的、基于授权的交互**。我们通过在系统核心中，构建一套丰富的**“协议化交互”**能力来解决这个问题。
+
+* **可验证身份**：一切交互的基础，是知道你在与谁对话。**去中心化标识符 (DID)** 使得每一个“大道”都能拥有一个主权的、可被验证的身份，而无需依赖任何中央权威。
+* **精细化授权**：连接不等于敞开大门。通过**可验证凭证 (VCs)**，一个用户可以授予另一个“大道”对特定数据子集的、用于特定目的的、可撤销的精细化访问权限。这使得在不牺牲隐私或控制权的前提下，进行项目协作或分享策展信息成为可能。
+* **基于信任的发现**：我们的**“应用集市”**模型，避免了一个单一的发现中心。取而代之的是，用户通过订阅他们所信任的“策展人”列表，来组成他们自己的“联邦”。这创造了由共享上下文和信任所构成的、互相交叠的社区，允许意外的发现，而不会被单一的全局算法所困。
+
+通过这些协议，独立的“大道”可以自愿地组成**高信任度的协作圈**，从而创造一个由互相依存的主权个体组成的、充满活力的网络，而非一堆孤岛的集合。
+
+## 2. 权力的悖论：增强而不暴政
+
+**张力所在**：当我们为用户提供一个强大的、深度理解其生活的个性化AI时，我们是否也提供了一个可能被用于“自我欺骗”或“操纵他人”的工具？我们如何能在赋予巨大力量的同时，抑制其被滥用的潜力？
+
+**我们的方案**：我们通过在系统的构造中，直接构建**内部和外部的“制衡”**机制来应对。
+
+* **内在的认知制衡**：我们官方的**“大道AI伙伴”**，在架构上以我们的“AI伦理宪章”为宪法。其核心宗旨之一就是**“多元视角法则”**。AI被设计为扮演一个制衡用户自身偏见的内部角色。它的任务是识别潜在的回音室效应，并主动地、但又尊重地，呈现高质量的、可供选择的观点，以拓宽用户的认知边界。
+* **社会化的信誉机制**：我们无法控制用户的意图，但生态系统可以为行为带来结果。所有重要的跨“大道”交互，都可以与用户的DID相关联。恶意的或不可信的行为，可以被可验证地记录和在社区内分享，从而导致其信誉的降低。这个社会化层为负责任的行为，创造了强大的激励，因为一个信誉不佳的“大道”将很难建立新的信任连接。
+* **不可侵犯的主权边界**：最终，`元`核心的安全模型是最终的防线。没有用户的明确、加密的同意，任何“大道”的数据都无法被读取，其状态也无法被改变。这保护了整个社区，免受任何单一行动者潜在的“暴政”影响。
+
+本质上，我们的设计致力于创造被赋能的、但又负责任的主权个体，让他们能够在一个丰富、健康的去中心化生态系统中，进行连接、协作与共存。

zh/src/project/CONTRIBUTING.md

@@ -12,21 +12,21 @@
 
 您无需成为 Rust 专家才能做出贡献。有很多方式可以提供帮助：
 
-* **代码**: 为`元 (Meta Unit)`贡献代码，构建新的`化身`，或为`dao-verify`套件开发插件。可以从寻找标记有`"good first issue"`的 issue 开始。
-* **文档**: 提升这些文档的清晰度，撰写教程，或添加示例。
-* **翻译**: 将我们的文档翻译成新的语言。
-* **设计**: 帮助我们的参考`化身`进行UI/UX设计。
-* **社区**: 回答问题，帮助新用户，并参与讨论。
+* **核心开发**: 为`元`库和核心协议（使用Rust）贡献代码。
+* **`道器`开发**: 创建新的`道器`，它可以包含**`器`（UI）组件**和**`核`（无界面逻辑）组件**。
+* **文档与翻译**: 改进这些文档，撰写教程，以及将它们翻译成新的语言。
+* **用户支持与社区管理**: 帮助新用户，回答问题，营造一个热情、互助的氛围。
+* **设计与用户体验**: 为参考`道器`贡献UI/UX设计，并为生态定义设计模式。
 
 ## 你的第一个 Pull Request
 
 我们对所有的代码贡献都采用标准的 GitHub Fork & Pull Request 工作流。
 
-1. **Fork 仓库**: 创建目标仓库的一份你自己的拷贝（例如 `dao-os-docs`, `meta-unit`, `avatar-browser-ext`）。
-2. **创建分支**: 从 `main` 分支创建一个新的分支用于你的变更。请使用描述性的名称（例如 `feat/add-note-encryption` 或 `fix/typo-in-readme`）。
+1. **Fork 仓库**: 创建目标仓库的一份你自己的拷贝（例如 `dao-os-docs`, `meta-unit`）。
+2. **创建分支**: 从 `main` 分支创建一个新的分支用于你的变更。请使用描述性的名称（例如 `feat/add-note-encryption`）。
 3. **进行更改**: 编写你的代码及相应的测试。
-4. **运行本地检查**: 在提交前，请确保你运行了所有本地测试（如 `cargo test`）和代码格式化工具。
-5. **Commit 你的变更**:我们鼓励使用 [Conventional Commits](https://www.conventionalcommits.org/zh/v1.0.0/) 规范，以获得清晰可读的 commit 消息。
+4. **运行本地检查**: 在提交前，请确保你运行了所有本地测试和代码格式化工具。
+5. **Commit 你的变更**: 我们鼓励使用 Conventional Commits 规范，以获得清晰可读的 commit 消息。
 6. **Push到你的Fork**: 将你的变更推送到你自己的 Fork 仓库。
 7. **开启一个 Pull Request**: 从你的分支向 Dao OS 官方仓库的 `main` 分支提交一个 Pull Request (PR)。
 8. **描述你的 PR**: 在 PR 的描述中，请链接任何相关的 issue，并清晰地描述你正在解决的问题和你的解决方案。

zh/src/project/governance.md

@@ -14,26 +14,36 @@
 
 “大道”的初始创建者和核心贡献者，将自己的角色视为一个不断演进的过程。
 
-* **在早期阶段（架构师）**: 我们的主要角色是架构师——为项目奠定一个坚实且自洽的基础，定义核心协议，并构建初始工具。这需要一个专注的愿景来确保项目在正确的道路上启航。
-* **在长期阶段（园丁）**: 随着生态的成熟，我们的角色将从“事必躬亲”转变为“照料花园”。我们将专注于提供更好的工具（如`dao-verify`套件）、维护核心基础设施，并赋能社区去建设和创新。我们的目标，是让我们自己变得越来越不那么“不可或缺”。
+* **在早期阶段（架构师）**: 我们的主要角色是架构师——为项目奠定一个坚实且自洽的基础，定义核心协议，并构建初始工具。
+* **在长期阶段（园丁）**: 随着生态的成熟，我们的角色将从“事必躬亲”转变为“照料花园”。我们将专注于提供更好的工具、维护核心基础设施，并赋能社区去建设和创新。
+
+## 生态策略：聚焦与引爆
+
+作为一个由个人开发者发起的项目，我们认识到自身资源的有限性。试图为所有可能的技术栈提供同等的一流支持，是一条通往平庸的道路。
+
+因此，我们采纳**“聚焦一点，引爆生态”**的战略。
+
+我们核心团队的开发精力，将集中于打造**一条“黄金路径”**，使其体验足够高效和愉悦，以此作为吸引第一波开发者的主要催化剂。这条被选定的路径，就是**Nim 统一开发套件**，它利用 Nim 语言的独特能力，从单一代码库构建 WASM 后端和 Web UI 前端。
+
+这并不排斥其他的开发路径（如 Rust + TypeScript 或原生集成）。它们在协议层面依然被完全支持。然而，它们被视为**“社区/高级路径”**，我们依赖社区的力量来构建相应的工具链和最佳实践。
 
 ## 如何贡献
 
 贡献的形式多种多样，每一种都同样宝贵。你可以通过以下方式帮助建设“大道”：
 
-* **核心开发**: 为`元 (Meta Unit)`和核心协议（使用Rust）贡献代码。
-* **化身与模块开发**: 为不同平台创建新的`化身`，或开发新的模块来扩展`元`的能力。
+* **核心开发**: 为`元`库和核心协议（使用Rust）贡献代码。
+* **`道器`开发**: 创建新的`道器`，它可以包含**`器`（UI）组件**和**`核`（无界面逻辑）组件**。
 * **文档与翻译**: 改进这些文档，撰写教程，以及将它们翻译成新的语言。
 * **用户支持与社区管理**: 帮助新用户，回答问题，营造一个热情、互助的氛围。
-* **设计与用户体验**: 为我们的参考`化身`贡献UI/UX设计，并为生态定义设计模式。
+* **设计与用户体验**: 为参考`道器`贡献UI/UX设计，并为生态定义设计模式。
 
 ## 决策流程
 
 我们的治理模式，被设计为与项目共同成长。
 
-1. **早期阶段 (阶段 I-II)**: 决策将由**核心团队**在公共渠道进行开放讨论后做出。这种类似“仁慈的终身独裁者 (BDFL)”的模式，对于项目初期的速度和一致性是必要的。
-2. **成长阶段 (阶段 III-IV)**: 对于核心协议或架构的重大变更，我们将引入一个正式的 **RFC (请求评论) 流程**。这允许社区中的任何人撰写详细的提案，该提案将在公开辩论和完善后，再做出最终决定。
-3. **成熟阶段 (未来)**: 我们致力于在未来探索并过渡到更去中心化的治理机制，例如由贡献者选举产生的技术委员会，或基于DAO的财库与协议管理模型。
+1. **早期阶段 (阶段 I-II)**: 决策将由**核心团队**在公共渠道进行开放讨论后做出。
+2. **成长阶段 (阶段 III-IV)**: 对于核心协议或架构的重大变更，我们将引入一个正式的 **RFC (请求评论) 流程**。
+3. **成熟阶段 (未来)**: 我们致力于在未来探索并过渡到更去中心化的治理机制。
 
 ## 沟通渠道
 

zh/src/project/roadmap.md

@@ -0,0 +1,54 @@
+# 发展路线图
+
+本文档概述了大道 (Dao OS) 的战略路线图。它的设计旨在做到既雄心勃勃又切合实际，专注于在每个阶段都能交付有意义的增量价值。这是一份活的文档，可能会随着社区反馈和技术突破而演进。
+
+---
+
+### 第一阶段：创世 (Genesis) - 基石与桥梁
+
+* **时间**：2025年第三季度 - 2025年第四季度
+* **核心目标**：构建核心的`元`库，以及让开发者能够开始构建的关键工具。
+* **关键里程碑**:
+  * 完成 v0.1 版本的`元`核心 API 规范。
+  * 使用 Rust 开发 v0.1 版本的`元`，包含`SecretStore`、`NoteStore`和基础的P2P同步服务。
+  * 开发第一个官方的**`核化身 (Core Avatar)`**：一个用于初始化“大道”、管理密钥和基础诊断的命令行工具。
+  * 发布 v0.1 版本的 **`dao.js` SDK**，使任何 Web 应用都能成为一个临时的`器化身`。
+* **功能故事**: “作为一名开发者，我能用一个命令行工具来初始化我的‘道’。然后，我可以利用一个简单的Web应用，导入`dao.js`库，并看着它连接上我的‘道’，读取一条测试笔记。这个地基是真实存在的。”
+
+---
+
+### 第二阶段：显现 (Manifestation) - 第一个“道器”诞生
+
+* **时间**：2026年第一季度 - 2026年第二季度
+* **核心目标**：发布第一个官方的、高价值的`道器`，以展示生态系统的力量并吸引早期用户。
+* **关键里程碑**:
+  * 完善并稳定化`元`内部的核心服务。
+  * 遵循我们的“良木为材”战略，**改造一个结构清晰的开源笔记或密码管理器**，通过集成`dao.js` SDK，使其成为我们的第一个官方`器道器`。
+  * 实现**“渐进式主权”**的用户上手流程。
+  * 上线包含完整用户和开发者文档的项目官网。
+* **功能故事**: “我正在浏览器里使用一个优美、快速、且熟悉的笔记应用。但我知道，它的数据是端到端加密的，通过P2P网络在我的所有设备间无缝同步，没有任何中心服务器。这是第一个真正属于我自己的应用。”
+
+---
+
+### 第三阶段：协同 (Synergy) - 连接不同的大道
+
+* **时间**：2026年第三季度 - 2026年第四季度
+* **核心目标**：实现不同用户“大道”之间的、可信的安全交互，并为高级AI奠定基础。
+* **关键里程碑**:
+  * 在`元`中实现 W3C DID 和 VC 模块。
+  * 开发一个跨“大道”通信的PoC应用（例如，分享一篇经过签名、可验证的笔记）。
+  * 启动官方**“大道AI伙伴”`核道器`**的基础研究和原型设计。
+* **功能故事**: “我拥有了一个主权的数字身份。我可以授权另一个‘大道’用户有限的、加密的访问权限来读取我的一篇笔记，而无需通过任何第三方平台。我们可以组建真正的信任网络。”
+
+---
+
+### 第四阶段：生态 (Ecosystem) - 应用集市开张
+
+* **时间**：2027年及以后
+* **核心目标**：将“大道”从一个拥有旗舰应用的平台，演进为一个繁荣、开放的生态系统。
+* **关键里程碑**:
+  * 发布 v1.0 稳定版的`元` API。
+  * 发布第一个官方的**“大道AI伙伴”`核道器`**，为用户提供主动的、智能的辅助。
+  * 上线**“应用集市”**协议和一个参考策展索引。
+  * 为构建高级原生**`器化身`**（例如用Flutter/Swift）提供官方指南和社区支持。
+* **功能故事**: “我的‘大道’活了过来。我的AI伙伴帮助我管理我的一天。我可以在一个去中心化的集市里，寻找社区构建的、可信的新`道器`。我的数字生活是主权的、智能的，并且在不断成长。”

zh/src/specifications/tech_overview.md

@@ -0,0 +1,44 @@
+# 技术总览
+
+本文档为希望构建**`道器`**（与大道OS生态集成的应用和服务）的开发者，提供了关于架构、核心技术和指导原则的高阶概览。
+
+## 技术指导原则
+
+* **是“库”，而非“框架”**: 大道OS不是一个限制性的框架。**`元`**是一个可移植的库，你将它集成到你自己的应用中，在不规定你应用内部架构的前提下，为其赋能。
+* **开放与多语言主义**: 任何应用，无论用何种语言编写，都可以成为一个**`化身`**（`元`的运行时）。我们通过将`元`同时提供为**WASM库**（用于Web和脚本语言）和**原生库**（`.so`, `.dll`, `.a`，用于系统语言）来实现这一点。
+* **API优先**: 所有与`元`的交互，都通过一个稳定的、版本化的、文档齐全的API进行。
+* **安全第一**: `元`是一个安全保险库。所有数据默认端到端加密，所有交互都由一个严格的、用户控制的权限系统来管理。
+
+## 核心集成：应用如何“化身”
+
+创造一个`道器`的旅程，始于集成`元`库，这个动作会即时地将正在运行的应用进程，转变为用户“大道”网络中的一个主权`化身`。我们提供两条主要的集成路径。
+
+### 1. Web 集成路径 (通过 `dao.js` SDK)
+
+这是对于 Web 开发者来说，最简单、最平滑的路径。
+
+* **工作原理**: 开发者可以利用任何新的或现有的Web应用。通过引入我们的 `dao.js` SDK，他的Web应用就获得了加载`元`的WASM二进制文件 (`dao.wasm`) 的能力。
+* **“化身”转变**: 一旦用户授权，运行这个Web应用的**浏览器标签页，就变成了一个临时的`化身`**。Web应用的JavaScript代码，就可以通过`dao.js`桥暴露出的高层API，与`元`进行通信。
+* **最适用于**: 快速构建`器`组件 (`Facet Implement`)，创建数据可视化面板，以及将现有的PWA（渐进式Web应用）集成到“大道”生态中。
+
+### 2. 原生集成路径 (通过 FFI)
+
+这条路径为原生应用提供了最强的性能和最深的系统集成能力。
+
+* **工作原理**: 一个原生应用（用Rust, Go, Swift, Kotlin, C++等编写）的开发者，可以直接链接`元`的原生库。
+* **“化身”转变**: 正在运行的原生应用进程，就变成了一个持久的**`化身`**。应用代码通过一个**外部函数接口（FFI）**桥，与`元`的核心服务通信。
+* **最适用于**:
+  * 在服务器或NAS设备上，创建强大的、7x24小时在线的**`核`组件 (`Core Implement`)**。
+  * 构建高性能的原生**`器`组件 (`Facet Implement`)**，比如我们理想中基于Flutter的移动客户端。
+  * 改造现有的开源原生应用。
+
+## 关键技术与协议
+
+| 类别 | 技术 / 协议 | 用途 |
+| :--- | :--- | :--- |
+| **核心库** | Rust -> WASM / 原生库 | 为`元`创建一个单一的、安全的、高性能的核心逻辑。 |
+| **Web集成** | `dao.js` SDK (JS/TS) | 任何Web应用成为`化身`的桥梁。 |
+| **P2P网络** | `libp2p` | 模块化的节点发现、传输和安全通道。 |
+| **数据同步** | 无冲突复制数据类型 (CRDTs) | 确保各`化身`间的最终一致性。 |
+| **身份** | DID & VC | 主权身份与可互操作的、基于密码学的信任。 |
+| **数据序列化** | Protocol Buffers (Protobuf) | 用于API的高效、语言无关的数据结构。 |