Prep towards alpha release

.github/workflows/release-binaries.yml

@@ -21,15 +21,12 @@ jobs:
           - target: aarch64-apple-darwin
             os: macos-latest
             artifact: symposium-darwin-arm64
-          - target: x86_64-unknown-linux-gnu
+          - target: x86_64-unknown-linux-musl
             os: ubuntu-latest
             artifact: symposium-linux-x64
-          - target: aarch64-unknown-linux-gnu
+          - target: aarch64-unknown-linux-musl
             os: ubuntu-latest
             artifact: symposium-linux-arm64
-          - target: x86_64-unknown-linux-musl
-            os: ubuntu-latest
-            artifact: symposium-linux-x64-musl
           - target: x86_64-pc-windows-msvc
             os: windows-latest
             artifact: symposium-windows-x64
@@ -48,22 +45,26 @@ jobs:
         with:
           targets: ${{ matrix.target }}
 
-      - name: Install cross-compilation tools (Linux ARM64)
-        if: matrix.target == 'aarch64-unknown-linux-gnu'
+      - name: Install musl tools (x86_64)
+        if: matrix.target == 'x86_64-unknown-linux-musl'
         run: |
           sudo apt-get update
-          sudo apt-get install -y gcc-aarch64-linux-gnu
+          sudo apt-get install -y musl-tools
 
-      - name: Install musl tools
-        if: matrix.target == 'x86_64-unknown-linux-musl'
+      - name: Install musl cross-compilation tools (aarch64)
+        if: matrix.target == 'aarch64-unknown-linux-musl'
         run: |
           sudo apt-get update
-          sudo apt-get install -y musl-tools
+          sudo apt-get install -y musl-tools gcc-aarch64-linux-gnu musl-dev
+          # Install aarch64 musl cross toolchain
+          wget -q https://musl.cc/aarch64-linux-musl-cross.tgz
+          tar -xzf aarch64-linux-musl-cross.tgz
+          echo "$PWD/aarch64-linux-musl-cross/bin" >> $GITHUB_PATH
 
       - name: Build
         run: cargo build --release --target ${{ matrix.target }} -p symposium-acp-agent
         env:
-          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_GNU_LINKER: aarch64-linux-gnu-gcc
+          CARGO_TARGET_AARCH64_UNKNOWN_LINUX_MUSL_LINKER: aarch64-linux-musl-gcc
 
       - name: Package (Unix)
         if: runner.os != 'Windows'

md/SUMMARY.md

@@ -12,23 +12,26 @@
 
 - [Introduction](./introduction.md)
 - [About](./about.md)
+  - [Agent mods](./about-mods.md)
 
 # Using Symposium
 
 - [How to install](./install.md)
     - [VSCode](./install-vscode.md)
+    - [Zed](./install-zed.md)
+    - [Rust Rover](./install-rust-rover.md)
     - [Other editors](./install-other.md)
 - [Using Symposium](./using/symposium.md)
-- [Built-in extensions](./using/extensions.md)
+- [Built-in mods](./using/mods.md)
     - [Sparkle](./using/sparkle.md)
     - [Ferris](./using/ferris.md)
     - [Cargo](./using/cargo.md)
 
-# Authoring Agent Extensions
+# Authoring Agent Mods
 
-- [Creating Agent Extensions](./extensions/creating-extensions.md)
-- [Recommending Agent Extensions](./extensions/recommending-extensions.md)
-- [Publishing Agent Extensions](./extensions/publishing-extensions.md)
+- [Creating Agent Mods](./mods/creating-mods.md)
+- [Recommending Agent Mods](./mods/recommending-mods.md)
+- [Publishing Agent Mods](./mods/publishing-mods.md)
 
 # Contributing to Symposium
 
@@ -37,7 +40,7 @@
   - [Common Issues](./design/common-issues.md)
   - [Distribution](./design/distribution.md)
   - [Agent Registry](./design/agent-registry.md)
-  - [Agent Extensions](./design/extensions.md)
+  - [Agent Mods](./design/mods.md)
   - [Components](./design/components.md)
   - [Run Mode](./design/run-mode.md)
   - [Rust Crate Sources](./design/rust-crate-sources.md)
@@ -49,7 +52,7 @@
       - [Testing](./design/vscode-extension/testing.md)
       - [Testing Implementation](./design/vscode-extension/testing-implementation.md)
       - [Packaging](./design/vscode-extension/packaging.md)
-      - [Extension UI](./design/vscode-extension/extensions.md)
+      - [Mods UI](./design/vscode-extension/mods.md)
       - [Language Model Provider](./design/vscode-extension/lm-provider.md)
       - [Language Model Tool Bridging](./design/vscode-extension/lm-tool-bridging.md)
       - [Implementation Status](./design/vscode-extension/implementation-status.md)

md/about-mods.md

@@ -0,0 +1,60 @@
+# Agent mods
+
+Agent mods extend what your AI agent can do. A mod sits between your editor and your agent, observing the conversation and enriching it.
+
+```mermaid
+sequenceDiagram
+    participant Editor
+    participant Mod
+    participant Agent
+
+    Editor->>Mod: prompt
+    Mod->>Agent: prompt (enriched)
+    Agent->>Mod: response
+    Mod->>Editor: response
+```
+
+## What can a mod do?
+
+Mods are proxies that see every message passing between editor and agent. This lets them:
+
+**Inject context** - Add information to prompts before the agent sees them. A mod could insert the current date, project conventions, or relevant documentation.
+
+**Provide tools** - Give the agent new capabilities. The [Ferris mod](./using/ferris.md) provides tools for fetching Rust crate sources; the [Cargo mod](./using/cargo.md) provides `cargo build` and `cargo test`.
+
+**Transform output** - Modify responses before they reach the editor. A mod could reformat code, add annotations, or filter sensitive information.
+
+**Coordinate behavior** - Manage multi-step workflows, track state across turns, or orchestrate multiple agents.
+
+## Mods you might already know
+
+If you've used **MCP servers**, Symposium can inject them as mods. An MCP server provides tools and resources that the agent can invoke - Symposium wraps it with an adapter that handles the protocol translation.
+
+If you've used **agent skills** (like Claude Code's slash commands), those can also be injected as mods. Skills define prompts and coordinate agent behavior - Symposium adapts them to work with any ACP-compatible agent.
+
+Mods are a superset of both - they can do everything MCP servers and skills can do, plus intercept and transform the conversation itself.
+
+## Composing mods
+
+Multiple mods can chain together. Each mod handles its own concern without needing to know about the others:
+
+```mermaid
+sequenceDiagram
+    participant Editor
+    participant Sparkle
+    participant Ferris
+    participant Agent
+
+    Editor->>Sparkle: prompt
+    Sparkle->>Ferris: prompt + collaboration context
+    Ferris->>Agent: prompt + collaboration context + Rust tools
+    Agent->>Ferris: response
+    Ferris->>Sparkle: response
+    Sparkle->>Editor: response
+```
+
+This modularity is the key advantage. Mods are interoperable - anyone can write one, and they compose without coordination.
+
+## Built-in and community mods
+
+Symposium ships with [built-in mods](./using/extensions.md) for Rust development. But the ecosystem is open - anyone can [create](./extensions/creating-extensions.md) and [publish](./extensions/publishing-extensions.md) mods, and crate authors can [recommend mods](./extensions/recommending-extensions.md) that help agents use their libraries.

md/about.md

@@ -1,36 +1,21 @@
-# What we want to achieve
+# What Symposium is
 
-You fire up your agent of choice through Symposium. It has a more collaborative style, remembers the way you like to work. It knows about your dependencies and incorporates advice supplied by the crate authors on how best to use them. You can install extensions that transform the agent — new skills, new MCP servers, or more advanced capabilities like custom GUI interfaces and new ways of working.
+Symposium is a wrapper that extends your AI agent of choice to be a more proficient Rust coder. Symposium is built on the [Agent Client Protocol (ACP)](https://agentclientprotocol.com/) which means it is compatible with any AI agent ([Claude Code, Codex, Kiro CLI, etc](./using/symposium.md#selecting-an-agent)) and any editor ([VSCode](./install-vscode.md), [Zed](./install-zed.md), [Rust Rover](./install-rust-rover.md), [NeoVim, Emacs, etc](./install-other.md)).
 
-## AI the Rust Way
+# Agent mods: a portable extension mechanism
 
-Symposium brings Rust's design philosophy to AI-assisted development.
+Symposium is based on the idea of [agent mods](./about-mods.md). Mods extend what your agent can do. You might already be familiar with MCP servers or agent skills -- both of these work as mods. But mods can also do things those can't, like intercepting messages or transforming tool output before the agent sees it. And unlike things like Claude Code Plugins, mods work with any ACP-supporting agent.
 
-<div class="pillars">
+# Leverage the wisdom of crates.io
 
-<div class="pillar">
-<h3>Leverage the wisdom of <s>the crowd</s> crates.io</h3>
+Symposium ships with mods for [Rust development](./using/mods.md). But Symposium's superpower is the ecosystem. Anyone can publish mods, and crate authors can recommend mods that help your agent use their libraries well. Just like Rust's crate ecosystem, the community teaches your agent new tricks.
 
-Rust embraces a small stdlib and a rich crate ecosystem. Symposium brings that philosophy to AI: your dependencies can teach your agent how to use them. Add a crate, and your agent learns its idioms, patterns, and best practices.
+# How do I use it?
 
-Beyond crate knowledge, we want to make it easy to publish agent extensions that others can try out and adopt just by adding a line to their configuration — the same way you'd add a dependency to `Cargo.toml`.
+Ready to give Symposium a try? It's as easy as [installing an extension in your editor of choice](./install.md):
 
-</div>
-
-<div class="pillar">
-<h3>Stability without stagnation</h3>
-
-Rust evolves quickly and agents' training data goes stale. Symposium helps your agent take advantage of the latest Rust features and learn how to use new or private crates — things not found in its training data.
-
-We provide guides and context that keep models up-to-date, helping them write idiomatic Rust rather than JavaScript-in-disguise.
-
-</div>
-
-<div class="pillar">
-<h3>Open, portable, and vendor neutral</h3>
-
-Open source tools that everyone can improve. Build extensions once, use them with any ACP-compatible agent. No vendor lock-in.
-
-</div>
-
-</div>
+* [VSCode](./install-vscode.md)
+* [Zed](./install-zed.md)
+* [Rust Rover](./install-rust-rover.md)
+* [NeoVim, Emacs, etc](./install-other.md)
+* [...and more!](./install.md)

md/design/agent-registry.md

@@ -1,12 +1,12 @@
 # Agent Registry
 
-Symposium supports multiple ACP-compatible agents and extensions. Users can select from built-in defaults or add entries from the [ACP Agent Registry](https://github.com/agentclientprotocol/registry).
+Symposium supports multiple ACP-compatible agents and mods. Users can select from built-in defaults or add entries from the [ACP Agent Registry](https://github.com/agentclientprotocol/registry).
 
 The registry resolution logic lives in `symposium-acp-agent` and is shared across all editor integrations.
 
 ## Agent Configuration
 
-Each agent or extension is represented as an `AgentConfig` object:
+Each agent or mod is represented as an `AgentConfig` object:
 
 ```typescript
 interface AgentConfig {
@@ -117,14 +117,14 @@ At spawn time, the extension resolves the distribution to a command (priority or
 
 ### Cargo Distribution
 
-The cargo distribution installs agents/extensions from crates.io:
+The cargo distribution installs agents/mods from crates.io:
 
 ```json
 {
-  "id": "my-rust-extension",
+  "id": "my-rust-mod",
   "distribution": {
     "cargo": {
-      "crate": "my-acp-extension",
+      "crate": "my-acp-mod",
       "version": "0.1.0"
     }
   }

md/design/implementation-overview.md

@@ -37,7 +37,7 @@ symposium-acp-agent run-with --proxy sparkle --proxy ferris
 
 ## Proxy Configuration
 
-Use `--proxy <name>` to specify which extensions to include. Order matters - proxies are chained in the order specified.
+Use `--proxy <name>` to specify which mods to include. Order matters - proxies are chained in the order specified.
 
 Known proxies: `sparkle`, `ferris`, `cargo`