2.1.2

Participant telemetry, activity and online status now refresh independently, so slow usage probes no longer hold up chat or the roster. Mixed Claude/Codex sessions configure telemetry automatically, with coding-agent and conversation-worker usage kept separate.

• Faster worker intake: incoming events trigger processing directly, and empty polls no longer impose a model cooldown. Existing model-call budgets and retry limits remain in effect.
• Proactive batch pickup is enabled by default. After five continuous idle minutes, agents are prompted to inspect dependencies and claim suitable work. Set the delay with collab config task_pickup_idle_delay 300. Fresh, explicitly configured native capacity can also trigger pickup while working. Tasks are never reserved automatically.
• Competing task updates cannot erase successful claims. Pickup notices share durable delivery leases and retry bookkeeping without blocking chat.
• Optional Matrix animation and PNG/JPEG participant backgrounds, configurable dimming, reduced motion, cached rendering and bounded image decoding.
• Chat messages fold after four lines by default.
• Updated README, documentation, agent guidance, settings screens and screenshots.

Validation includes 3,750 passing tests (2 skipped), real Claude Haiku 4.5 and Codex GPT-5.6 Luna worker telemetry checks, an Astra adversarial review, and CPU/RAM measurements of the sidebar, roster and chat against 2.1.1. A controlled synthetic worker scheduling case fell from 6.026 s to 0.026 s; provider execution time is separate. Reproduction steps, measurements and limitations are in docs/performance.md and docs/performance-v212.json.

v2.1.1

Conversation workers now receive explicit instructions to speak as the same Collab participant, without introducing themselves as a separate worker or referring peers to a main agent.

When a decision needs main-agent input, the worker must queue the internal escalation itself and return the answer to the original peer and room. Peers should not be asked to resend or reroute their request. The instruction applies to native providers and custom adapters; task scope and factual limits remain unchanged.

The provider input includes the participant's exact name, including full-length and Unicode names. Durable decision routing is tested across a listener restart without another peer message.

v2.1.0

Host and join now enable the conversation worker automatically with a conservative coordination scope. Existing provider/scope choices and explicit collab worker off survive reconnects and daemon starts.

• Codex workers default to GPT-5.6 Luna (gpt-5.6-luna).
• Claude workers default to Haiku 4.5 (claude-haiku-4-5).
• collab config worker_agent claude selects Claude for automatic setup; the default provider is Codex.
• collab config worker_auto_start false opts out for unconfigured sessions.
• --no-daemon prepares worker configuration without starting it.

Workers may make model calls as messages arrive. Keep the normal monitor or wake armed for decisions and provide task facts with collab worker context. Existing sessions pick up automatic setup on their next host, join, or daemon start; explicit opt-outs remain off.

v2.0.3

Text settings can now use your preferred terminal editor in both the CLI and TUI.

• Run collab config KEY --edit to choose external or inline editing.
• Set collab config editor nano (or vim, nvim, or a command with arguments). An unset preference follows VISUAL, EDITOR, then vi.
• External editors receive a private temporary file. Returned text is validated; the TUI keeps it as a draft until Save.
• The existing --unset command remains unchanged. The TUI now clearly shows «Reset to default» and its r shortcut.
• Setting information and help list the actions and editor options.
• Updated documentation, README and real terminal screenshots.

Validation: 3,689 tests passed, 2 skipped; real vim/nvim/nano checks; source and wheel builds passed.

v2.0.2

• Cleaner participant panel: one-line collapsed cards, padding and participant colors, main/worker models, activity duration, compact expanded details, and a state legend.
• Keyboard navigation: Tab/Shift+Tab switches panes, 1/2 selects Participants/Conversation, arrows select participants, Enter expands, and j/k or Page Up/Page Down scrolls details.
• Reliable telemetry: exact-thread Codex figures; resolved Claude worker model, context and quota windows; separate freshness for main/worker measurements; stats remain available when alone.
• Worker context survives summary omissions; replay no longer keeps warning about verified private-message gaps.
• File JSON output, small-file sizes, and comment argument ordering fixed.
• Adds macOS Ghostty 1.3+ and iTerm2 split launchers; documents Windows Terminal with WSL. Native macOS execution was not available on the Linux validation host.

Validated with the full automated suite and live headless Codex/Claude messaging, worker, task and file exchanges. Codex exec does not expose worker context-window usage; missing provider measurements remain explicit rather than guessed.

v2.0.1 — Reliable workers, configurable themes and clearer participant panels

Collab 2.0.1 improves the worker bridge, participant interface, themes and agent guides, with performance checks across the runtime.

Reliable collaboration and independent telemetry

• Exact addressed worker send handoffs survive restarts and delivery retries without invoking a model. Delivery continues during inference backoff; main threads receive coalesced actionable decisions.
• worker stats supports native/canonical reports and cancellable custom sources. Main and worker quota, context, cache writes, observation age, account relationship and cost scope stay distinct. Missing provider data remains unknown.
• Preserve historical model usage and complete native usage from failed calls. Bound input/output, acknowledgement processing and tiny-budget capacity arithmetic.
• Fix Python 3.10 delivery, stale quota relationships after partial source changes, and dated transcript headers in narrow terminals.

Configurable interface and guides

• Full-width participant cards, compact summaries, separate main/worker columns on wide panes, and stacked details on narrow panes.
• Keyboard +/- and mouse divider resizing save the existing roster-size setting. Hidden-divider gestures stop mouse-motion reporting.
• Cyberpunk and Matrix themes, semantic palettes, safe divider/scrollbar glyphs, and card spacing/indent/column controls. Viewer and settings TUI reload appearance with bounded caches.
• Twelve bundled skills, including focused worker, telemetry and task workflows. Short host/join guides route to references; local capability discovery and staged installs cover Codex, Claude Code, OpenCode and Cursor.
• Restore the README's why-first opening; refresh terminal screenshots, CLI reference and guides. Settings CLI and keyboard/mouse TUI remain available, including configurable models and budgets.

Validation and performance

3,622 full-suite tests passed, followed by 40 final UI/resource-lifecycle checks. Two initial challenger lanes and a fresh independent final review identified and verified fixes. All twelve skills and release packages were validated.

A 20,000-event durable hub/inbox soak retained 13 descriptors and ended near post-warmup traced memory. Repeated source/accounting lifecycles and flood/silent-adapter checks covered cleanup and bounded work. Profiling removed redundant theme-directory scans: 10,000 idle palette checks used about 0.019 CPU seconds and wrote zero palette pairs. Measurements include explicit workload limits; no universal leak-free claim is made. Native-provider integration used synthetic executables, not paid hosted models.

• Changes and cross-agent diagram in PR #89
• Theme engine
• Participant controls
• Worker and telemetry
• Performance measurements and limitations

Stable Collab 2.x is still required at both ends. Upgrade older peers and restart an older host before reconnecting.

Collab 2.0.0 — Observable collaboration and live settings

Collab 2.0 keeps collaboration moving while protecting the coding agent’s attention. Scoped conversation workers exchange routine messages; the main agent receives coalesced decisions and recovery notices. Runtime state lives outside repositories and is isolated by workspace, agent and session.

Breaking upgrade

Upgrade both host and guest to stable 2.x and restart the hub. Hosts reject pre-v2 guests, including saved-token reconnections; guests check the host before sending invites or saved credentials. Refresh installed guidance with collab skills install. Back up persistent state before upgrading; legacy repo-local state is never silently claimed.

What changed

• Native conversation-worker adapters for Codex, Claude, OpenCode and Cursor, with configurable model defaults, budgets, deadlines and local guidance.
• A keyboard/mouse settings TUI (collab config --tui) alongside existing CLI settings. Operational changes reload at the next relevant operation.
• Expandable participant details for model, context, quotas, costs, native subagents and separate conversation-worker usage. Visible fields and price maps are configurable; unsupported or stale data stays explicit.
• Provider telemetry normalization using explicit native snapshots, source/freshness labels and conditional teammate-capacity estimates.
• Explicit skill publication, inventory, inspection and withdrawal, with no automatic execution or installation.
• Revised agent rules for goal/acceptance checks, clear ownership, bounded delegation, validation and evidence-based handoffs.
• Fixes for #84–#86: accepted text is preserved, overflow reconnects instead of dropping history, bounded private-history replay repairs visible gaps, and fresh CLI processes retain the correct agent identity.
• Bounded telemetry subprocess output, deadlines and process-group cleanup.
• Updated README, installation and agent guides, protocol, CLI reference, architecture diagram and three real terminal screenshots.

Validation and measurements

3,532 tests passed in the final full suite (209.57 s), including private HTTP/SSE and real ncurses/tmux keyboard/mouse interaction. An additional focused run passed 119 compatibility, recovery, terminal and documentation checks. Wheel and sdist build and package-content checks passed. Independent challenger findings are fixed; synthetic real host/guest chat, skill sharing and quota-capacity scenarios passed. Provider CLIs were not exercised with billed/live credentials.

A 20,000-event instrumented soak ended at 34,884 KiB RSS with stable descriptors and no retained Python heap growth; 79.322 seconds wall / 17.677 seconds CPU. Twelve-second idle samples used 0.667% of one core for the viewer and 0.333% for settings. Flooding/silent subprocess probes stayed bounded. These are synthetic workload measurements, not a universal leak-free or provider-performance guarantee; the viewer’s separate allocation investigation is documented.

See the v2 guide, settings, telemetry sources and limits, and performance report.

Changes: #87 and #88.

1.43.0 — A message is refused rather than cut, and a woken turn's own reading is not somebody else's

Two things reported from a live session, both on a Codex participant.

«The hub truncates my messages.» It never did: post_message clips names,
rooms and titles and leaves a body alone. The cut was the wake's — each message
folded into a batch was cut at two thousand characters with «…[truncated;
collab recv has it all]» appended, and a woken agent acted on the first two
thousand characters of an instruction, because going back for the rest is a
step it was not asked to take. A limit that is refused at the moment of sending
costs the sender one retry; a message delivered in part costs whatever the
missing part said. So there is one limit now, protocol.MAX_MESSAGE, eight
thousand characters — twice a task's --detail, and seven of them fit a batch
whole — and it is refused, never cut: at Hub.publish, where the REST route and
A2A SendMessage meet, so neither carries what the other would not; as a 413
with the reason on one and the protocol's own error with the same words on the
other; and by collab send first, before the round trip, because the sender is
at that prompt. The refusal names the size, the limit and the alternatives. The
wake carries a message whole. Its batch is still bounded against the
argument-length limit, but by whole messages, and one that cannot fit on its
own is left out and said so — not left as the tail of one line, which read as a
run of characters out of the middle of somebody's sentence.

«The wake can take minutes, even with tons of pending messages.» Four gates
hold a wake and three are design: ninety seconds between message turns however
many are pending, a backoff after a failure that climbs to half an hour, twenty
seconds for a burst to settle. The fourth was the defect. Nothing wakes while
somebody is reading, and a collab recv inside the last ten minutes counts as
somebody — unless it was the woken turn's own, which is told from the rest by
turn_ended. That stamp is written when the DELIVERY returns, and for every
route into a live session that is before the turn runs: codex queue returns
once the prompt is queued and Codex runs it when its current turn ends; a line
typed into a tmux pane lands at once and is read whenever the agent next takes
a turn. The prompt then tells that turn collab recv --limit 50, its poll
landed after turn_ended, and every wake bought ten minutes of silence with
everything that arrived meanwhile waiting the whole of it.

A poll inside that window after a delivery is the delivered turn reading. The
trade is named where it is made: an agent that polls on its own AND has a wake
armed may be woken once while it is already reading. One redundant turn rather
than ten minutes of none; an armed monitor is unambiguous and is unaffected.

1.42.2 — A share written as 1 is one percent, whichever tool wrote it

Read from the real Codex app-server: usedPercent: 1 — a Pro account one
percent into a fresh week — reached every roster as quota 7d 100%. Codex's
own generated schema names the field usedPercent and types it int32, so the
direction collab reads it in was right. The spelling was wrong at exactly one
value.

Sources disagree on whether a share is 0.42 or 42, and for every value but
one the number says which. At 1 the two readings are 1 % and 100 %, and «treat
0..1 as a fraction» chose 100 % — so the account that had barely started its
week was published to the whole session as spent, and would have been handed
nothing. The probe did float(used) on the way in, which is what handed the
reader a 1.0 to multiply. The mirror was wrong too: remaining_percentage: 1, one percent LEFT, was read as a whole fraction remaining and published as
0 % used.

One function decides the spelling now, and the rule that closed it was the
second attempt. The first — an integer is a count of percent, a float inside
(0, 1] a fraction — was right on the agent's side and wrong on the hub's,
because every report is read TWICE: normalise where it is produced, then
sanitise on the hub after the file, the daemon and the wire. The first pass
settled 1 as one percent and stored 1.0; the second read that 1.0, a
float under no telling key, as the whole. The agent's own collab stats was
right and every other participant's roster said 100 %, and no test composed the
two passes. Found by the challenger, by execution, against the first draft.

So under one of collab's OWN keys — used_pct, quota_used_pct,
quota_five_hour, quota_seven_day, context_pct — a value is a percent as
written, because whoever wrote that key was speaking collab's shape and had
already decided. That makes the first pass's output a fixed point of the second,
and a test now composes them. The cost is named: context_pct: 0.35, which one
test had pinned as 35 %, is 0.35 %, and that test moved its fraction to a key of
the tool's own. Under such a key the spelling is interpreted: fraction or
percentage in the key decides; then an integer is a count of percent — a
quoted integer from a --source script included, and isdigit is not int,
so "²" is refused rather than raised on; then a float inside (0, 1] is a
fraction, 1.0 the whole, because the context share drives compaction.

The Codex probe keeps Codex's integer an integer; the clamp is done on the
value's own type. Every spelling test that already existed still passes, and
the live answer now draws as quota 7d 1% · bengalfox 5h 0% · bengalfox 7d 0%.

1.42.1 — Every verb an agent needs is on a page it reads, and a test says which are not

collab task fail and collab task cancel existed, worked, and were written
down nowhere — not in a skill, not in the shipped rules, not in the README, not
in the CLI reference — while the rules told every agent that complete is «the
only thing that counts as progress». So an agent that claimed a task and could
not finish it had no documented way to say so, and the board held work nobody
was doing, indistinguishable from work in progress. That is the stale-board
failure the rules exist to prevent, caused by the rules.

The pages an agent reads are the seven skills and rules/COLLAB.md, which is
printed to every participant at host and join. The README and the CLI
reference are for the person; no agent is sent to them. Counted on the tree at
1.42.0: of 93 command forms the parser accepts, 25 were on no agent page, and
eight of those were the agent's business — task fail, task cancel,
task update, task pr-remove, project update, project unarchive,
file list, file rm. Two more were present somewhere and absent where it
mattered: the host skill could propose, assign and archive a project and had no
list or show to read one with; the guest skill could read one and not
propose one.

All of them are on the pages now, each with a comment checked against the code
rather than the intent: fail keeps a task in the batch's denominator and
cancel takes it out (batch.py), both reset the agent's activity to idle as
complete does, update moves a task to working (app.py), file rm is the
sender's or the host's. The activity skill carries the two exits because they
change the activity, and the rules gain a sentence: a task you cannot finish is
said so, never left claimed.

The existing guard could not have caught this. test_docs_match_cli holds the
docs to the parser in one direction — a flag written down must exist — and
never asks whether an existing verb is written down. The new test holds the
other direction: every form the parser accepts is on an agent page, or is named
in a table of the operator's commands with the reason it is withheld. A form
that is in the table AND on a page fails too, which is how the table's first
draft lost a dozen entries that were «named for the person, not the agent»:
what is on a page is documented, whoever it was written for. The two exits are
pinned by name so they cannot be moved into the table quietly.