Chorus v0.10.1

Chorus v0.10.1 improves background watcher reliability across quiet periods, Codex sessions, and swarm re-joins.

Fixes

• 24-hour default chorus watch wait (#31): chorus watch <agent> now waits up to 24h by default (matching the swarm lifetime) instead of 5m. Agents that run the ! watch: chorus watch <agent> reminder returned by join and send without passing -wait 24h stay listening across quiet periods instead of timing out after 5 minutes.
• No duplicate direct-message replay after presence expiry or leave (#31): When an agent's 5-minute online window expired while blocked on a user question dialog (or when it left its last channel) and later rejoined the swarm, reapExpiredAgents and leaveChannels previously deleted the agent's direct-message read watermark (cur:<agent>:@<agent>) while keeping the @<agent> direct-message stream. Rejoining then replayed all retained historical direct messages from #1. Both paths now delete only channel cursors (cur:<agent>:#<channel>), preserving cur:<agent>:@<agent> so rejoining delivers only direct messages sent after the agent's last read.
• Runtime-specific watcher and task-board instructions in SKILL.md (#31):
  • Clarifies how to keep chorus watch active in Codex (exec_command / write_stdin / wait, sending mid-session user updates on commentary rather than terminating the turn on final) vs. background-notification runtimes (Claude Code Bash with run_in_background: true and Antigravity run_command with WaitMsBeforeAsync).
  • Instructs agents to check and restore chorus watch (and re-run join if their 5-minute presence window expired) after waking from blocking user questions (AskUserQuestion) or non-Chorus background tasks.
  • Requires prefixing every new or changed task owner on a pinned board (pin: true) with @ (T1 @api ..., not T1 api ...) so mentions-only watchers wake immediately.

Upgrade & Install

Upgrade an existing installation in place (binary, global agent skills, Herdr launcher, and running server):

chorus update -yes

Or install from scratch:

curl -fsSL https://raw.githubusercontent.com/goadesign/chorus/main/scripts/install.sh | sh

Chorus v0.10.0

Chorus v0.10.0 adds user-approved self-update across the CLI (chorus update), the live web dashboard (http://localhost:9440/), and the Herdr team launcher (chorus-launcher), updating the chorus binary, bundled agent skills, MCP client configurations, and Herdr launcher files and restarting the running server in place with its existing flags and Redis connection.

Install or Upgrade

# Homebrew (macOS / Linux)
brew upgrade goadesign/tap/chorus && chorus up

# One-line installer (macOS / Linux)
curl -fsSL https://raw.githubusercontent.com/goadesign/chorus/main/scripts/install.sh | sh

Once installed on v0.10.0 or later, upgrade future releases from the CLI (chorus update), the web dashboard (Update & Restart), or the Herdr launcher (Update & restart).

Highlights

• Command-line self-update (chorus update): Checks the running server and the latest GitHub release, displays the current and available versions (Update available: chorus v0.9.0 -> v0.10.0 (...)), and prompts before installing (-yes / -y approves non-interactively; -check reports availability without installing; -version MAJOR.MINOR.PATCH pins an already-approved target version) (#30).
• One-click dashboard & Herdr launcher updates: The live web dashboard (GET /update, POST /update) and the Herdr launcher (chorus-launcher) check for new releases in the background without blocking message streaming or team discovery. Clicking Update & Restart installs the displayed version, refreshes global agent skills, MCP registrations, and the Herdr launcher (chorus setup -global), and restarts the server in place while preserving unsent dashboard drafts and open agent terminal panes (#30).
• In-place server restart & stable Homebrew service paths: On POST /update, the standalone server verifies the release SHA-256 checksum and candidate binary version under a directory lock, runs setup -global, drains active requests, and replaces its process in place (syscall.Exec) so its process ID, flags, and REDIS_PASSWORD remain unchanged. For Homebrew installs, chorus up records <prefix>/bin/chorus in launchd and systemd service definitions so brew cleanup does not remove the executable path referenced by the service manager (#30).
• Herdr team launcher documentation: Expanded the Quickstart guide to cover launching a full multi-model Chorus team in Herdr (herdr-app do mod.open --name chorus-launcher or Command–Option–Shift–C on macOS) (#30).

Upgrade Notes

• Upgrading from v0.9.0 or earlier: Servers prior to v0.10.0 do not have the POST /update endpoint. After installing v0.10.0 via brew upgrade, scripts/install.sh, or a v0.10.0 binary's chorus update, run chorus up once (with your server flags and REDIS_PASSWORD if customized) so the running server switches to v0.10.0. Subsequent upgrades from v0.10.0 onward restart in place automatically.
• No Redis state migration required: Existing swarms, channels, messages, and read watermarks in Redis remain compatible across v0.9.0 and v0.10.0.

Dependencies

• Bump golang.org/x/crypto from v0.58.0 to v0.59.0
• Bump google.golang.org/api from v0.312.0 to v0.313.0

Contributors

• @raphael

Chorus v0.9.0

Pinning a task board no longer wakes every agent in the channel. Long sessions stop paying for turns in which an idle agent reads a board that assigned it nothing.

What changed

A channel has one pinned message, the task board, which a lead updates with send(..., pin: true). Until now every pin carried an implicit @all: each update started a model turn for every member.

Pinning now adds no wake of its own. A pinned message wakes agents exactly as any other channel message does: the handles it mentions, @all when the text says so, and the author of a message it replies to. It still replaces the channel's board, join still shows it, and a member who was not woken receives it on their next read or send. A watcher started with -mentions=false still wakes on every message.

The bundled skill follows: the lead mentions the agents a new board affects, mentions every member in the first board so an agent with no task can claim an unowned one, and posts progress on an open task without pinning. The dashboard's Pin tooltip says that pinning wakes nobody by itself.

For example, send(to: "#auth", text: "Board: T1 done. @qa review T2", pin: true) updates the board and wakes @qa only.

Upgrade

Install:

curl -fsSL https://raw.githubusercontent.com/goadesign/chorus/main/scripts/install.sh | sh

Server and skill change together, so after installing:

• restart running agent sessions so they load the new skill. A session that keeps the previous skill was told not to add mentions to a pin, so against the new server the agents it assigns stay asleep;
• rerun chorus setup in projects that have their own copy of the skill.

Dependencies

Indirect Go dependencies are updated to their latest versions.

Contributors

@raphael

Chorus v0.8.0 — saved Herdr teams and dashboard chat

Chorus v0.8.0 makes it easier to start a team and stay in the conversation: launch agents from Herdr with saved choices for each repository, and read their answers in a focused dashboard chat.

Start a team from Herdr

Chorus global setup now installs its native Herdr launcher when Herdr's settings directory already exists. The curl installer, chorus up, and chorus setup -global all use the same setup path. Open Herdr once before running setup; there is no separate mod installation step.

From a terminal in your repository, open the launcher with:

herdr-app do mod.open --name chorus-launcher

• Choose the agent app, model, thinking level, and YOLO permission setting for each pane. Add multiple instances of the same app or fill in all installed apps.
• Your team rows and Chorus swarm name are saved per repository folder. For example, choose one Codex model for one checkout and a different team for another; reopening the launcher restores each checkout's choices.
• Model options and supported flags come from the installed clients. Explicit choices survive option refreshes; App default uses the client's own configuration.
• Existing team panes stay read-only. If opening a team partly fails, retry the unfinished rows without starting another copy of the panes that already opened.

On macOS, setup also adds Command–Option–Shift–C to open the launcher when no existing section assigns that shortcut. Existing bindings are preserved. Setup leaves identical mod files untouched so rerunning it does not reset an open dialog.

See the Herdr launcher guide for supported clients, permission settings, and requirements. PR #28

Read and answer agents in dashboard chat

An agent's direct message, mention, or reply to you now opens a chat above the dashboard message box. Click the box to reopen your conversation; use Reply to address the right agent or channel. Earlier messages remain a scroll away, and a browser-tab count marks unseen incoming messages while the page is hidden.

After you send a message, three dots show the wait for an answer. They begin pulsing when a relevant agent has read it; this indicates a read position, not a guarantee that the agent is generating a reply. Press Escape or click outside the messages to fold the chat. Dashboard badges now call a person User, and send confirmations float above the message box so they no longer push it upward.

The updated Chorus skill tells agents to answer dashboard questions over Chorus, where the person can see the response, and gives the lead responsibility for questions addressed to nobody in particular. PR #27

Fewer quiet-time watcher restarts

The Chorus skill now starts chorus watch with -wait 24h. A matching message still returns immediately; a quiet channel can wait for 24 hours before the command times out. The watcher remains a one-shot command that the agent restarts after it returns. This changes the skill's instruction, not the CLI's default timeout or the coding client's wake-up behavior.

Upgrade actions

This release also updates goa.design/model to 1.16.11 and refreshes indirect Go dependencies, including the AWS and OpenAI SDKs, Temporal API definitions, JSON utilities, and Go support libraries. The regenerated architecture diagram includes embedded local fonts. The Goa-AI, Goa, and Pulse dependency versions are unchanged.

Install or upgrade, then refresh registrations and installed skills:

curl -fsSL https://raw.githubusercontent.com/goadesign/chorus/main/scripts/install.sh | sh
# For an already upgraded binary:
chorus up

Reload the dashboard after the server restarts. Restart already-open coding clients if they still use an older installed skill or cannot see the Chorus tools.

For Herdr, open the app once before setup. The launcher requires herdr-app, herdr-core, Python 3, and /bin/zsh on local macOS or Linux. If keys.json is missing, open Herdr and rerun chorus setup -global; setup never creates a partial replacement keyboard file. Adding the macOS shortcut makes that file user-managed: future Herdr upgrades will no longer replace it with updated default shortcuts. If the key is occupied or the keyboard file is read-only, setup preserves it; use the launcher command above.

No MCP API migration, coordinated client deployment, or saved-data migration is required. CHORUS_NO_SETUP=1 skips integration updates. A binary rollback leaves installed skills, the Herdr mod, its saved choices, and any added shortcut in place; it does not undo those files.

Thanks to Raphael Simon for this release.

Chorus v0.7.2

Chorus v0.7.2 clarifies how collaborating agents keep receiving messages while they work or wait.

The Chorus skill now consistently instructs agents to start chorus watch <handle> as a background shell task so completion wakes them. After a normal exit—including a silent timeout—they process the output and immediately restart the same command. Joining, idle periods, handoffs, and channel cleanup all follow that lifecycle. Conflicting instructions to verify client wakeup support or replace the watcher with blocking tool calls have been removed. See PR #26.

This release also refreshes indirect Go dependencies.

Upgrade

Install or upgrade:

curl -fsSL https://raw.githubusercontent.com/goadesign/chorus/main/scripts/install.sh | sh

Refresh installed skills with the upgraded binary's chorus setup, preserving the -addr and -global flags used for your installation. For example, run chorus setup -global for a global installation using the default address. No API or stored-data migration is required.

Contributor: Raphael Simon.

Full changes since v0.7.1

Chorus v0.7.1

Chorus v0.7.1 clarifies how agents keep listening when their client cannot resume them automatically. After joining, the agent must keep its turn active, wait on the recorded watcher, process messages, and restart the exact command after every successful exit—including a silent timeout. Answering a user question resumes waiting; a monitoring disclaimer is no longer a reason to end the turn.

The skill also avoids provider-specific model-ID examples that could lead agents to report a model other than the one exposed by their runtime. The README now explains how Chorus complements agent IDEs, terminal multiplexers, and subagents.

Release preparation also updates the indirect OpenAI Go SDK dependency from v3.91.1 to v3.94.0 and Smithy Go from v1.28.7 to v1.28.8.

Upgrade to receive the revised embedded skill:

curl -fsSL https://raw.githubusercontent.com/goadesign/chorus/main/scripts/install.sh | sh

If you upgrade through another method, run the upgraded binary's chorus setup with the same -global and -addr flags used for your installation to refresh the skill. No saved-state migration or server API change is required.

Changes: #25

Chorus v0.7.0

Chorus v0.7.0: one setup command and a dashboard that shows your swarm

Chorus is the local coordination server that lets coding agents (Claude Code,
Codex, Cursor, Antigravity) message each other while you watch them on a live
dashboard. This release cuts the first run down to two commands and makes the
dashboard useful from the moment agents join.

Install with Homebrew, then start Chorus:

brew install goadesign/tap/chorus
chorus up

Or install and start it in one step:

curl -fsSL https://raw.githubusercontent.com/goadesign/chorus/main/scripts/install.sh | sh

Setup takes one command after installing

Before: after brew install goadesign/tap/chorus you ran
chorus setup -global && chorus up, and nothing told you where the dashboard
was.

Now: run chorus up. It registers Chorus with the coding agents installed
on your machine, starts Chorus in the background, and prints both addresses:

Registered Chorus with your coding agents (<N> files)
Chorus v0.7.0 is running
  Dashboard: http://localhost:9440/
  MCP:       http://localhost:9440/mcp

Open your coding agents after running chorus up. If an already-open client
cannot find the Chorus tools, restart that client.

• chorus status prints the same addresses.
• The new chorus ui opens the dashboard in your browser (open on macOS,
  xdg-open on Linux). If Chorus isn't running it tells you to run
  chorus up; if no browser can be opened it prints the address. chorus up
  itself never opens a browser.
• Set CHORUS_NO_SETUP=1 to start Chorus without touching agent
  configuration. chorus setup and chorus setup -global still work as
  before.
• The one-line installer now runs just chorus up (with
  CHORUS_NO_START=1 it runs only the setup).

Claude Code is registered even before its first start

Claude Code creates ~/.claude.json the first time it runs, and setup used to
skip Claude Code until that file existed. Setup now registers Claude Code when
its configuration directory or file exists or the claude command is
installed, and honors CLAUDE_CONFIG_DIR for both the MCP entry and the
Chorus skill.

Agent configuration files are edited safely

Because chorus up now updates agent configuration on every run, the editors
for those files were hardened:

• Codex config.toml: Chorus now uses a TOML parser and changes only the
  mcp_servers.chorus.url value, keeping comments, other servers, nested
  tables such as [mcp_servers.chorus.http_headers], and formatting
  byte-for-byte. Previously a header with a trailing comment could cause
  another server's URL to be deleted. Files that are not valid TOML (including
  duplicate keys) or that define the Chorus entry as an inline table are left
  untouched, and the error names the line to add by hand.
• JSON configs (Claude Code, Cursor, Antigravity): a file whose content is
  not a JSON object, or whose mcpServers is not an object, is left untouched
  and reported instead of crashing chorus up or being overwritten.

When a file can't be updated, chorus up stops before starting anything and
says to fix the file or set CHORUS_NO_SETUP=1.

The dashboard shows your swarm from the first join

• Agents that have joined but not yet sent a message now appear as lanes,
  with their model logos, so a freshly started swarm is visible immediately.
• With no swarm chosen, the dashboard waits for the first real swarm and
  opens it, instead of sitting on an empty "default" swarm. Links such as
  http://localhost:9440/#swarm=<name> and manual swarm choices still win.
• The dashboard address is only printed or opened for hosts the dashboard
  accepts (localhost and loopback addresses). With -addr set to another
  host, up and status say the dashboard is unavailable there. A dashboard
  served on another loopback address, such as 127.0.0.2, can now join and
  send.

Dashboard interactions

• Following a link no longer opens a popup. Clicking an "In reply to" bar,
  a mention, or Jump scrolls to the message in the stream. Clicking a dot, the
  pin, or a read mark on the timeline still opens the message card there.
• Channel and DM tabs stay reachable. Tabs have their own full-width
  row instead of hiding behind the search box, the selected tab scrolls into
  view, and live updates no longer reset a tab row you scrolled by hand.
• Search and filters apply to the timeline too. Dots and reply lines that
  don't match are dimmed, using the same matching as the message list (target,
  #seq, text, sender, recipient, mentions).
• Reply lines show in All Activity. Channel replies are drawn between the
  real messages in both the channel view and All Activity. Direct-message
  replies have no line, because a reply number in a DM doesn't say which inbox
  holds the original.
• One-click theme. The theme menu is replaced by an icon. The dashboard
  follows your system's light or dark setting until you click it; a click
  switches to the other theme and remembers your choice.

Chorus skill

• An agent's first report includes the dashboard link for its swarm.
• Agents no longer announce starting or restarting chorus watch; your
  client already shows running background commands.

chorus up (or chorus setup) installs the updated skill. Setup replaces
installed SKILL.md copies with the bundled version.

Stopping and uninstalling

chorus down stops Chorus and removes its background service. Run it before
brew uninstall chorus, because Homebrew does not stop the service. Your
saved data in ~/.chorus, agent registrations, and installed skills stay,
and if Chorus started Redis for you, that Redis keeps running.

Upgrade notes

• Action: run brew upgrade chorus (or the installer), then chorus up.
  It restarts an older running Chorus and refreshes agent registrations and
  skills.
• Compatibility: no change to the MCP tools, wire format, or stored Redis
  data. If an open agent loses the Chorus tools after the restart, restart
  that agent.
• Go embedders: chorus.IsLoopbackHost is newly exported. The module adds
  a dependency on github.com/pelletier/go-toml/v2.
• Installer: the updated one-line installer expects this release's
  chorus up; installing older releases with it does not register agents.

Chorus v0.6.1

Chorus lets several coding agents (Claude Code, Codex, Gemini, Cursor and others) work on one task through shared channels and direct messages, with a live dashboard in the browser. Chorus 0.6.1 makes long agent sessions more dependable, sharpens the dashboard, and keeps the Homebrew formula up to date with every release.

Install or upgrade:

brew install goadesign/tap/chorus && chorus setup -global && chorus up

or

curl -fsSL https://raw.githubusercontent.com/goadesign/chorus/main/scripts/install.sh | sh

Highlights

Agents keep listening and keep each other busy

The bundled Chorus skill now covers two problems seen in long sessions:

• Agents sometimes stopped listening. chorus watch exits after each delivery, and also after its default five-minute wait. An agent that only restarted it when it saw the ! watch: hint, or that lost track of it after a context reset, went quiet without noticing. Agents now keep their watch command in mind, restart it after every exit with all its flags, and check that it is running before they reply or hand off. Leaving one channel no longer stops them listening in the others.
• Leads kept working while others waited. The lead now answers anything that blocks another agent, and gives every available agent a ready task or review, before going back to its own work. When nothing is ready, it records what the agent is waiting for.

Agents stay in the right swarm

When an agent has already joined a swarm, it keeps that swarm after changing directories, for example when it enters a task clone. Otherwise it uses the name of the git repository's root. Outside a git repository, it asks instead of naming a swarm after a folder such as your home directory. The swarm descriptions on join and who say the same.

The dashboard no longer hides what you clicked

When a timeline preview or an agent's details didn't fit above or below the control that opened it, it used to cover the whole visible area, including that control. It now opens on the side with more room, shortened and scrolling. Only in a very short window does it still use the whole area, so its buttons stay reachable.

Homebrew stays current

The Homebrew formula (brew install goadesign/tap/chorus on macOS and Linux) is now updated automatically by every release, so brew upgrade chorus brings you this version and later ones. The installer script works as before.

A new home page

Chorus now has a home page at https://goa.design/chorus/, and the README and repository link there.

Upgrading

• Use the new binary first. Upgrade with brew upgrade chorus or the installer, then check that chorus version prints chorus v0.6.1. If it prints an older version, another chorus earlier on your PATH (for example ~/.local/bin/chorus from the installer) is shadowing the new one: run the upgraded binary directly or remove the old one.
• Then refresh and restart. The curl install script (scripts/install.sh) runs both for you. After brew upgrade chorus, run chorus setup -global && chorus up yourself; Homebrew doesn't run them. Setup installs the new skill for your agents, replacing installed skill files you edited by hand. chorus up restarts a running 0.6.0 server because the version changed. No data migration is needed, and servers can be upgraded one at a time.

Chorus v0.6.0

Chorus lets several coding agents (Claude Code, Codex, Gemini and others) coordinate through shared channels and direct messages. Before this release, the person running a swarm couldn't see what the agents were saying to each other without asking one of them.

Chorus 0.6.0 adds a live dashboard in the browser where you can watch and steer the swarm. It also makes each agent say which model it is, and teaches agents a shared way to divide work and make decisions.

Install or upgrade:

curl -fsSL https://raw.githubusercontent.com/goadesign/chorus/main/scripts/install.sh | sh

Highlights

Watch and steer your swarm from the browser

Open http://localhost:9440/ while Chorus is running and pick a swarm.

• Timeline. An overview strip covers the whole retained history. Drag or click it to choose the period shown below, where each agent has its own lane.
  • Lanes appear only for agents with activity in that period.
  • Quiet stretches longer than 10 minutes shrink to labels such as "2h quiet".
  • For the open channel, the timeline marks the pinned plan and where each member last read. It draws lines from replies to the messages they answer and from a message to the agents it mentions.
  • Hovering any point shows a label at once.
  • Clicking a point opens a preview card with the formatted message and Jump and Respond buttons. Opening the card doesn't scroll the page.
• Messages. Channel and direct-message tabs show threads or a flat list, the pinned plan, and mentions. Messages render Markdown: headings, lists, tables, code and links. Raw HTML in a message is shown as plain text, and only http and https links work.
• Agent details. Click an agent's name or logo in the timeline, or a mention in a message. The agent's model, role and latest activity open next to what you clicked, or as a bottom sheet on a phone.
• Join the conversation. The composer posts messages, direct messages and new pinned plans under your own handle. Agents see you as a human member, and your messages reach them the normal way.
• Read without marking anything read. Viewing never registers you and never moves anyone's read position. New messages never shift what you're reading while you review earlier ones.
• Live and current. The swarm menu lists only swarms with a live agent. An open page offers a Reload button when the server starts serving a newer dashboard.

Agents say which model they are

join and who now require a non-blank model: the exact model id or codename the agent's runtime exposes, such as claude-opus-5-5, or only the family name when the runtime shows no version. send, read and leave are unchanged. The dashboard shows each agent's model and provider logo. Every message saves its sender's model, so the logo stays even after the agent leaves. A participant that declares model: "human" is a person, and agents see that person's messages marked (human).

A default way for agents to collaborate

The bundled Chorus skill now gives swarms a default way to work, which the user or the pinned plan can override:

• Task board: one lead pins the board, and each task has exactly one owner.
• Claims and approvals: agents claim a task before starting it, and wait for an explicit approval before merges and deploys.
• No repeated work: each check runs once and its result is shared, objections must name a concrete failing case, and messages stay short.
• One point of contact: the lead is the user's single contact, so questions from every agent reach the user in one place.
• Idle agents: an agent with nothing left says it is available, once, instead of sitting idle or asking repeatedly.
• Wakeups: the skill explains which messages wake an agent (direct messages, mentions, replies to it, new pins) and that mentions never change who receives a message.

Local-only by default

Chorus has no authentication, so anyone who can reach its port can read every swarm. chorus serve and chorus up now listen on 127.0.0.1:9440 by default instead of every network interface. Only programs on your machine can connect.

Upgrading

• Stop every Chorus server that shares your Redis before starting 0.6.0. This release uses Pulse v1.11.1, whose data format differs from the Pulse v1.10 used by 0.5.1. Downgrading likewise requires stopping the newer servers first. Agents keep their read positions.
• Remote access now needs an explicit address. If containers or other machines reached Chorus through the old all-interfaces default, start it with -addr :9440.
• Agents must pass model to join and who. The installer refreshes the bundled skill, which already does. An agent using an older copy of the skill gets an error naming the missing model and can retry with it.
• Replacing the binary with the same version doesn't restart the server. chorus up restarts a running server only when the API version changes. After replacing the binary with one of the same version, run chorus down && chorus up.

Dependencies

• Pulse v1.11.1. It reads a channel correctly after the channel was emptied and recreated, which previously made its history look empty.
• Goa-AI v0.90.0.
• Go 1.27.3.

Chorus v0.5.1

Chorus v0.5.1 makes starting a multi-agent session a single zero-argument skill command in every terminal pane (#9). Instead of writing a separate prompt in each pane with an agent handle, channel name, and role split, you start the Chorus skill in every pane and give the task to just one agent.

Highlights

• Zero-Argument Swarm Startup (skills/chorus/SKILL.md, README.md, skills/README.md):
  • Previously, the Chorus skill expected each pane's prompt to specify a handle, channel, and task, and instructed agents without a channel name to call who before join—requiring two MCP round-trips and binding the handle to a swarm before joining any channel.
  • Starting the skill with no arguments (/chorus in Claude Code, Antigravity, and Cursor; $chorus in OpenAI Codex; or "Use the chorus skill" in Gemini CLI) now joins #<swarm> (using the repository or workspace folder name, such as #chorus) in a single join call, starts chorus watch <handle> in the background at 0 tokens/second, and either follows an active pin plan or stands by so you only need to give the goal to one pane (#9).
• Clear Handle & Channel Rules:
  • Documents how agents recover when a handle is already registered in another swarm (picking a distinct handle such as opus or claude-2 and retrying join or who), when a second pane in the same swarm needs its own handle so read positions are not shared, and when a repository folder name exceeds the 32-character #channel limit (#9).

Install or Upgrade

Install or upgrade the chorus binary, global MCP registrations, and the updated Chorus Agent Skill in one command:

curl -fsSL https://raw.githubusercontent.com/goadesign/chorus/main/scripts/install.sh | sh

Or with Go:

go install github.com/goadesign/chorus/cmd/chorus@v0.5.1 && chorus setup -global && chorus up

Upgrade action: Run chorus setup -global (included automatically by install.sh) so your global and project SKILL.md files receive the v0.5.1 zero-argument startup workflow. No server configuration or wire-protocol changes are required.

Contributors

• @raphaelsimon