collab-a2a 2.1.2__tar.gz → 2.2.0__tar.gz

{collab_a2a-2.1.2/src/collab_a2a.egg-info → collab_a2a-2.2.0}/PKG-INFO

@@ -1,12 +1,13 @@
 Metadata-Version: 2.4
 Name: collab-a2a
-Version: 2.1.2
+Version: 2.2.0
 Summary: An A2A hub that lets coding agents on different machines talk, align on tasks, and discuss work in real time.
 License: MIT
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: a2a-sdk[fastapi]>=1.1.2
+Requires-Dist: cryptography>=46
+Requires-Dist: a2a-sdk[fastapi]<1.2,>=1.1.2
 Requires-Dist: uvicorn>=0.30
 Requires-Dist: httpx>=0.28.1
 Requires-Dist: httpx-sse>=0.4
@@ -15,6 +16,7 @@ Requires-Dist: Pillow>=12.1.1
 Requires-Dist: python-multipart>=0.0.18
 Requires-Dist: websockets>=14
 Requires-Dist: tzdata; platform_system == "Windows"
+Requires-Dist: cryptography>=42
 Provides-Extra: dev
 Requires-Dist: pytest>=8; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.24; extra == "dev"
@@ -90,6 +92,7 @@ To receive messages in real time, arm a Monitor on one of these:
 ```
 $ collab join https://a1b2c3.ngrok.app#FDfw... --focus "the client side"
 [ok]   joined s_bb9c59a3 as bob (host: alice)
+[ok]   using route https://a1b2c3.ngrok.app
 [ok]   listening
 [ok]   announced your focus: the client side
 
@@ -104,7 +107,7 @@ From that moment both agents receive each other's messages as they happen.
 
 ## Contents
 
-- [What changed in v2](#v2-settings-and-shared-capabilities)
+- [In 2.2.0](#in-220) · [What changed in v2](#v2-settings-and-shared-capabilities)
 - [How it works](#how-it-works) · [Install](#install) · [Quick start](#quick-start)
 - [Making an agent listen](#making-an-agent-listen) · [Saying what you are doing](#saying-what-you-are-doing) · [Commands](#commands)
 - [Watching the conversation](#watching-the-conversation) · [How it looks](#how-the-conversation-looks) · [Status line](#status-line) · [Files](#sharing-files-and-artifacts)
@@ -114,6 +117,106 @@ From that moment both agents receive each other's messages as they happen.
 
 ---
 
+## In 2.2.0
+
+What 2.2.0 adds since 2.1.2.
+
+- **Upgrade note: offline names are reserved.** A participant who goes offline
+  keeps their name: only the collab state that joined as them, presenting its
+  saved token, can rejoin under it, and an invite alone is refused. Clients
+  older than 2.2.0 do not send that token, so after going offline they cannot
+  rejoin under their own name until they upgrade; they can join under another
+  name meanwhile (#150).
+- **Reserved names and hub alarms.** `collab` and look-alikes are refused as
+  participant names, hub alarms show in a reserved banner, and security
+  alarms wake the agent (#168).
+- **Hand work over.** `collab task release --id T_xxx` gives up a claim, and
+  `collab task handoff --id T_xxx --to NAME` offers a task to one participant,
+  who accepts with `collab task claim`; the host may release a claim held by
+  someone offline. The people an ownership change concerns are told directly
+  (#177).
+- **Peers see less about you.** The metadata collab sends on its own (join
+  handshake, stats, activity) no longer carries your hostname, OS account,
+  working directory or git remote; a `machine-…` label says only whether two
+  agents share a machine, and `collab stats --json` no longer carries `user`
+  (#178). What you write in chat is still sent as written. Records a hub
+  stored before 2.2.0 are cleaned when served, not rewritten. Upgrade note: the machine identity is now random, generated once, so
+  each machine shows a new `machine-…` label the first time it runs 2.2.0.
+- **Strong approval is live with Windows Hello.** A skill request asked with
+  `--strong` opens collab's approval window; passkey approval is not in this
+  release (#181).
+- **One proxy for every session, by default.** `collab host` attaches to the
+  machine's shared proxy (`proxy` = `auto`) and a session's address becomes
+  `/s/<id>`; a session that served the bare domain with its own tunnel before
+  keeps it, so its old links still work. `collab config proxy off` or
+  `--tunnel own` opts out (#182).
+- **A batch says when it will be done.** `collab batch status` adds the elapsed
+  time and an ETA taken from the completions the hub recorded — «≥» once the
+  task in flight is past its turn, «done in» and «closed after» at the end.
+  The status line and `collab watch` show it beside the bar.
+- **The conversation worker follows the coding agent** and speaks for the main
+  agent while it is enabled: an automatic worker uses the provider of the agent
+  running collab (`worker_agent` `auto`) and realigns on the next join; the main
+  agent's messages, comments and file sends go through its durable outbox; and
+  it paces itself once half its budget is spent. A provider failure is classed (`auth`, `model`,
+  `rate_limit`, `network`, `other`): a rate limit waits 15 minutes to an hour,
+  an auth or model failure becomes one decision for the main agent and is
+  rechecked hourly, and the rest retry at the normal delay. Answers to a peer close the chain:
+  `collab worker reply ID TEXT --verbatim` sends your words as written,
+  `--instruct` lets the worker word them, and `--awaiting-human` tells the peer
+  your human is deciding.
+- **`collab dashboard`** — everyone's quota, reset times and shared skills in one
+  table, kept current by the daemon. Quota resets are read by one explicit
+  policy, and a figure that is not a percentage is left out.
+- **Skills on request.** `collab skills peers` lists what each participant
+  shares; `collab skills ask NAME --to PEER` asks one to run a skill, and
+  consent is the asked side's: on a terminal its human answers y/N, and an
+  agent may accept only with `--human-approved`, its statement that its human
+  agreed (`collab skills accept|decline ID`). A request asked with `--strong`
+  needs more, and is live in 2.2.0: a Windows Hello gesture in collab's
+  approval window, verified by the hub against a key the human enrolled
+  themselves (`collab consent enrol`); no flag or typed answer accepts it.
+  Passkey approval on other systems is not in this release. It holds only
+  between clients that have it (2.2.0 or later): an older asked side can still
+  accept the ordinary way,
+  which the asking side never counts as accepted.
+- **A quota and model route for every coding agent collab recognises.** Claude
+  Code (its status line) and Codex (its app-server and turn record) report
+  them; the others are recorded as unknown, with the reason — an unknown quota
+  stays unknown rather than reading as zero, and nested tools are not credited
+  to the outer one.
+- **Settings per agent.** An agent's own settings — its name, colour,
+  reporting and worker — stay with that agent, while machine settings such as
+  the theme stay shared, and a machine-wide telemetry opt-out still applies;
+  `collab config KEY VALUE --machine` makes it every agent's default here, and
+  `--kind` keeps it for every conversation of one agent kind.
+- **Work offers.** Joining a session, or finishing a task, offers available
+  batch work — and stays quiet when there is none.
+- **Sessions and resume.** `collab sessions` lists saved host and guest sessions
+  and `collab resume` reopens one in its original working path. Resuming an
+  identity another live agent holds is refused, naming what to do: close that
+  agent's terminal (its PID is printed), or use `--home` for a deliberate second
+  identity. `collab host --keep` and `collab resume --keep` keep a session after
+  the coding agent exits.
+- **Local and public routes** for one session: agents on the host's machine
+  join over loopback, a TLS entrance can serve a LAN, and the public tunnel
+  keeps working beside them ([local routes](docs/local-routes.md)).
+- **Tunnel refusals say why.** When ngrok refuses to start, `collab host`
+  prints its reason and the remedy; `collab config ngrok_domain NAME` sets a
+  reserved domain every new session uses.
+- **Identity, not names.** Private messages, files and queued worker replies
+  are bound to stable participant ids, so a rename cannot redirect them, and a
+  worker notice is re-checked just before it is delivered.
+- **`collab file list`** counts files that already ended, and `--all` shows
+  each with why — collected, expired or withdrawn.
+- **Roster efficiency.** Roster reads are coalesced and conditional, so an
+  unchanged roster is not sent again.
+- **Logs capped at 10 MB** each, at write time — `daemon.log`, `hub.log`,
+  `ngrok.log` and the new `worker.log`, one content-free line per worker attempt
+  ([state storage](docs/state-storage.md)).
+
+---
+
 ## Documentation
 
 This page is the tour. Two directories go further, and they are for different
@@ -190,6 +293,14 @@ the SSE `id:`. A reconnecting daemon sends `Last-Event-ID: 412` and the hub
 replays from the log. Kill the hub with `-9`, restart it: the feed resumes with
 no gap.
 
+One session remains reachable locally and through its public tunnel. A join
+can use verified private same-machine discovery. After an authenticated join,
+a client can select the host's advertised pinned TLS entrance on a reachable
+private network, then fall back publicly without changing membership. A link
+alone cannot authorize that LAN destination. Older links and clients retain
+their public route. [Route selection and recovery](docs/local-routes.md)
+describe trust checks, optional OpenSSL setup and measured local/tunnel costs.
+
 ## Install
 
 Two ways in. Take the first unless you intend to change collab itself.
@@ -305,8 +416,17 @@ current link. To keep one address across restarts, pin a reserved domain:
 
 ```bash
 collab host --domain your-name.ngrok-free.app
+collab config ngrok_domain your-name.ngrok-free.app   # or once, for every session
 ```
 
+The order is `--domain`; then a domain you gave this session with `--domain`
+before, which it keeps; then the `ngrok_domain` setting, which also moves
+sessions that only ever had the default — so correcting or clearing the
+setting takes effect at the next `collab host`. One domain serves one session at a time. If ngrok refuses to
+start — for example because that endpoint is already online in another ngrok
+process (`ERR_NGROK_334`) — `collab host` prints ngrok's own reason and the
+remedy, and the session stays usable on this machine.
+
 The link is the only credential for joining, so anyone holding it can get in. If
 it leaks, or you shared it more widely than you meant to, replace it:
 
@@ -368,7 +488,8 @@ told to arm a monitor it does not have arms nothing and stops looking.
 `collab check`'s `watching` line says the same thing whenever nothing is
 reading.
 
-Host and join enable a Codex/Luna conversation worker by default. Customize
+Host and join enable a conversation worker by default, on the coding agent's
+own provider and its lower-tier model (Claude Code → Haiku, Codex → Luna). Customize
 its provider and scope and supply current task facts:
 
 ```bash
@@ -387,15 +508,20 @@ escalation; it must not imply that a decision has already been made. The usual
 scope and supplied-facts limits still apply.
 
 The worker keeps answering peers while the main agent works. Keep the usual
-monitor or wake armed: it now carries worker decisions and recovery alerts.
+monitor or wake armed: it carries worker decisions, recovery alerts and hub
+approval-security alarms.
 Answers return to the worker and then to the waiting peer. Choose its provider
 independently of the coding host: Codex, Claude, OpenCode, Cursor, or a custom
-adapter. The defaults are Luna for Codex and Haiku 4.5 for Claude; OpenCode and
-Cursor require explicit models. Model failures never switch to a premium model.
+adapter. The defaults are Luna for Codex and Haiku 5.5 for Claude; OpenCode and
+Cursor require explicit models. Model failures never switch to a premium model;
+rate limits wait (at most an hour), and login or model errors become one pending
+decision and are rechecked only hourly instead of every retry.
 See [conversation workers](docs/conversation-worker.md) for setup, authentication,
 scope, limits, and the return path. Use `collab worker off` to disable it for
 this session, or `collab config worker_auto_start false` before setup to opt out.
-`collab config worker_agent claude` selects Claude/Haiku 4.5 for unconfigured sessions.
+Automatic setup follows the coding agent (Claude Code gets a Claude worker, Codex a
+Codex one); `collab config worker_agent codex|claude` pins a provider instead. While
+the worker is on, `collab send` is queued through it rather than posted directly.
 Explicit off and provider choices survive reconnects.
 
 Without a worker, automatic delivery is a compact inbox notice, with no peer message text. One
@@ -1167,12 +1293,14 @@ collab 1.7.0 — let coding agents talk to each other
 | `collab listen --follow` | stream events as lines (what a Monitor watches) |
 | `collab recv --wait N` | drain unread, optionally waiting |
 | `collab watch` | a full-screen live view: roster, usage and conversation |
-| `collab sessions` | sessions this repo has hosted before |
+| `collab sessions` | saved host and guest sessions for this participant |
+| `collab resume <id>` | resume a saved session in its original working path |
 | `collab kill` | end a session (its data is kept unless `--purge`) |
 | `collab join` | join the session running on this machine — no link needed |
 | `collab discover` | collab sessions running on this machine |
 | `collab join <id>` | join a particular one, when several are running — the id `discover` prints |
 | `collab stats` | what each agent reports about its usage, and when it reported it |
+| `collab dashboard` | everyone's quota windows, worker budget and shared skills, kept current by the daemon |
 | `collab rules [--default]` | how to behave in a session — what `host` and `join` print on arrival; `--default` is the shipped file alone, to seed a repo's `COLLAB.md` |
 | `collab update` | check for, and install, a newer collab, then re-run the installers for whatever was already installed |
 | `collab who` | roster: who is here, their repo, branch and focus |
@@ -1612,7 +1740,9 @@ re-sharing is a decision you make each time you resume.
 collab host                    # resume the most recent (the default)
 collab host --resume <id>      # resume a particular one
 collab host --fresh            # start an empty session instead
-collab sessions                # what this repo has hosted, and what each holds
+collab sessions                # saved host and guest sessions, with working paths
+collab resume <id>             # resume either role in its original working path
+collab resume <id> --keep      # keep it after the coding agent exits
 collab kill                    # end the current one — data kept, resumable
 collab kill --disarm           # and turn off the wake armed on it
 collab kill --all              # end every session this repo hosts
@@ -1670,6 +1800,14 @@ collab daemon start --keep
 collab config follow_agent off      # never follow, for any session
 ```
 
+`--keep` is remembered for that saved session, including listener restarts and
+host resume. It also detaches an already-running follower on its next ownership
+check; it does not need a restart to take effect. The choice is local to this
+participant's session and does not change another participant's lifecycle or the
+global `follow_agent` setting. Stop it explicitly with `collab kill` or
+`collab daemon stop`; a fresh session starts with the normal following policy.
+Combining `--keep` with `--no-daemon` still records the choice for a later start.
+
 Two minutes rather than at once, because quitting an agent and starting it again
 is common and should cost nothing: the next `collab host` or `collab join` from
 the new agent re-claims the session, and the daemon picks that up on its next
@@ -1857,7 +1995,12 @@ If a session is listed there it is yours to bring back — `collab host`, or
 `collab host --resume <id>` for a particular one — with its history and a fresh
 invite for others to rejoin. There is no need to ask whoever you were talking
 to restart anything. Only when nothing at all is listed is nothing running.
-`collab sessions` lists everything this repo has, running or not.
+`collab sessions` lists this participant’s saved host and guest sessions, running
+or not. `collab resume <id>` restores the original working path and identity;
+use `--home <state-folder>` with either command to select your own saved state
+from another workspace or coding-agent thread. A guest requires its host to be
+reachable. A missing working directory or unknown session ID fails without
+selecting another session. The calling shell’s directory does not change.
 
 A session is registered by its **hub**, so it stays discoverable and joinable
 even if its listener has stopped — the hub is what makes it reachable. Stopping
@@ -1914,11 +2057,22 @@ cannot hold up chat, activity or the participant roster.
 Claude Code and Codex telemetry configure automatically when hosting, joining
 or starting the daemon. `stats_auto_setup` is enabled by default. Routing belongs
 to each participant, so a mixed room keeps Claude and Codex sources separate.
+Every other agent collab detects (Gemini CLI, opencode, Cursor, Copilot CLI,
+goose, Amp) is recorded with its quota unknown and the reason, which
+`collab stats` and `collab check` show. On any switch of tool the previous
+tool's quota, model and context are withdrawn, and nothing is published in
+place of a missing figure. Markers are inherited, so a tool started inside
+another is credited only when every marker's tool is an agent process above
+it, nearest first; otherwise the quota is «nested tools; cannot attribute».
+A stale inherited marker therefore reads as unknown – the accepted cost.
 Explicit sources and explicit opt-outs take precedence. Worker usage remains a
 separate observation from its native provider response.
 
-The roster refreshes independently every three seconds and on activity/presence
-events. After 30 seconds without a successful fetch, connectivity becomes
+The roster refreshes independently every three seconds. Activity/presence
+invalidations share fixed 100 ms windows, with a trailing read for events that
+arrive during a fetch. Unchanged rosters use private conditional responses;
+finite roster JSON negotiates gzip while chat stays on its unbuffered SSE feed.
+After 30 seconds without a successful fetch or revalidation, connectivity becomes
 unknown, even if chat is live. Working/idle still describes reported activity.
 See [telemetry setup and controls](docs/telemetry.md) and
 [panel refresh behavior](docs/watch-panel.md).
@@ -1931,7 +2085,7 @@ Agents expose different sources:
 | **Antigravity** | automatic — same mechanism, its status line payload is understood too |
 | **Codex CLI** | automatic – setup binds the participant to its exact Codex thread and probes native usage and account limits |
 | **opencode** | `collab stats --report` from a plugin — a shell status line is still an [open request](https://github.com/anomalyco/opencode/issues/30295) |
-| **Gemini CLI** | `collab stats --report` — statusline is an [open request](https://github.com/google-gemini/gemini-cli/issues/8191); `/stats` shows the numbers |
+| **Gemini CLI** | quota unknown automatically – the CLI keeps it in process memory only; `collab stats --report` — statusline is an [open request](https://github.com/google-gemini/gemini-cli/issues/8191); `/stats` shows the numbers |
 | **anything else** | `collab stats --report` |
 
 ### Keeping them current
@@ -1952,6 +2106,12 @@ It is run and checked immediately, so a typo tells you at once rather than
 silently reporting nothing forever. `collab stats --source ''` clears it and
 persistently opts out of automatic polling. Unset `stats_command` to restore
 automatic routing; disabling `stats_auto_setup` also stops automatic polling.
+A telemetry opt-out set machine-wide (`collab config stats_auto_setup false
+--machine`, or an empty `stats_command` there) applies to every agent; a
+non-empty `stats_command` is per agent. One left in the machine file stops
+applying, and automatic setup installs nothing until the person adopts it
+(`collab config stats_command '<probe>'`) or clears it; host and join say so
+once, and `collab check` warns on every run until then.
 
 **Some agents will only tell a program, not a shell.** Codex has no status line
 and no usage flag, but its CLI ships an app-server that will say what quota is
@@ -2251,6 +2411,11 @@ only with the last of them — or after 30 minutes, whichever comes first.
 Someone who joins later may still fetch it while it lasts, but does not keep it
 alive; someone removed from the session does not hold it up.
 
+`collab file list` shows files still on the host and says how many have
+already ended; `collab file list --all` adds those, each marked collected,
+expired or withdrawn, so a file that left the list is never mistaken for one
+that was lost.
+
 ## Security
 
 - **Per-participant tokens.** An invite is exchanged once for your own bearer
@@ -2322,9 +2487,30 @@ records, and no amount of scrubbing entitles anybody to publish it unseen. With
 diagnostics off it still writes the header and tells you how to capture a log.
 
 Beside it, `daemon.log` and `hub.log` are the two processes' own output at more
-length. Those have always been kept and are not a record of anything in
-particular; a process rolls one aside when it opens it and finds it past two
-megabytes, keeping one previous generation.
+length, `ngrok.log` is the tunnel agent's, and `worker.log` has one JSON line per
+conversation-worker attempt — an opaque random `attempt` id, how far it got
+(`reserved`, `launched`,
+`committed`), its outcome (`output`, `no-op`, `invalid`, `failed`, `cancelled`,
+or `skipped-local` for a counted turn that called no model), what triggered it
+as counts by kind, the model, tokens and cost, reply and escalation counts, the
+class of any failure and how long it took — never what anybody said, who said
+it, or a provider's own error text. Every one of them is capped at 10 MB with its
+rotated generation — the live file, `<name>.1` and a rotation's `<name>.1.tmp`
+together — and the cap is applied AT WRITE TIME: whatever collab writes rotates
+first if it would carry the live file past 3 MiB, so no burst can take the file
+over its budget. ngrok never writes `ngrok.log` itself; its output goes through a
+small collector process that writes the file the same way and drops a flood
+past 256 KB a second, saying how many lines it dropped. A watcher thread
+remains as a safety net for the one thing that writes around the cap — an
+interpreter's own traceback on a crash, a few kilobytes once.
+
+Upgrading from 2.1.2: an older `collab host` started beside a newer hub renames
+`hub.log` aside to `hub.log.1` when it opens it, as 2.1.2 always did. The newer
+hub's logging notices the rename and starts a fresh `hub.log`, and the lines
+from before are in `hub.log.1`. Its raw stderr — a crash traceback — still
+points at the renamed file, which a later rotation replaces, so such a
+traceback can be lost; restarting the hub ends that. `collab logs` prints all three of
+collab's own.
 
 ## Settings
 
@@ -2349,13 +2535,15 @@ collab config --json              # the same table, for an agent to read
 
 | Setting | What it does | Also set by | Default |
 |---|---|---|---|
-| `display_name` | the name others see | `collab name <n>` | git `user.name`, else `$USER` |
+| `display_name` | the name others see | `collab name <n>` | the agent kind and a stable suffix, e.g. `claude-3f2a91c0` (a legacy machine-wide name is adopted by the first agent only) |
 | `color` | the colour others see you in | `collab color <hex>` | dealt from the palette |
 | `editor` | terminal editor command; empty follows VISUAL, EDITOR, then vi | — | empty |
 | `theme` | how the conversation is laid out | `collab theme <name>` | `classic` |
 | `timezone` | the zone dates and times are read in; an IANA name, or `auto` for the computer's own | — | `auto` |
 | `share_stats` | share your usage with the session | `collab stats --share on\|off` | `on` |
 | `rules` | print collab's rules of conduct at `host` and `join`; the pointer to the repo's own `COLLAB.md` always prints | — | `on` |
+| `ngrok_domain` | reserved ngrok domain `collab host` uses when `--domain` is not given; a session you gave its own `--domain` keeps it | `collab host --domain` | empty |
+| `proxy` | shared machine tunnel policy: on/auto share one machine tunnel, off gives each hub its own | `collab host --tunnel own\|proxy` | `auto` |
 | `watch_layout` | `split`, `tmux`, `chat` or `roster` | `collab watch --layout <l> --save` | `split` |
 | `watch_roster_size` | how much room the roster gets, in percent | `collab watch --roster-size <n> --save` | `30` |
 | `watch_roster_position` | `top`, `bottom`, `left` or `right` | `collab watch --roster-position <p> --save` | `top` |
@@ -2392,9 +2580,10 @@ asked to display is a worse surprise than the one it would be fixing. If the old
 key is still in your file, `collab config` says so in one line every time you
 list your settings, until you replace it.
 
-`display_name` and `color` here are the machine-wide defaults. Where two agents
-share one checkout each has its own name and colour in its own state directory,
-and `collab name` and `collab color` set those — see
+`display_name` and `color` are each agent's own, never inherited from the
+machine file (a value left there is shown as legacy, with how to adopt it).
+Where two agents share one checkout each has its own name and colour in its own
+state directory, and `collab name` and `collab color` set those — see
 [Two agents in one checkout](#two-agents-in-one-checkout).
 
 **A change reaches the sessions you already have open.** That is the rule for
@@ -2596,6 +2785,7 @@ retain the same internal layout:
     status.json           what the status line reads
     agent_stats.json      usage your agent reported, waiting to be shared
     daemon.pid daemon.log the listener; the pid file carries the boot it was written on
+    worker.db worker.log  the conversation worker's state, and one line per model turn
     hub.json              host only: port, invite and host token (0600)
     hub.db                host only: the session's event log
     hub.log ngrok.log     host only
@@ -2702,7 +2892,13 @@ Work that came from outside this repository, and the release it landed in:
 
 ## Proactive batch pickup
 
-Proactive pickup is enabled by default. After **five continuous idle minutes**, a
+Proactive pickup is enabled by default. Joining a batch offers unclaimed work
+immediately when you own no unfinished task. Completing your current task also
+prompts you to inspect and claim suitable next work without waiting for the lead.
+These foreground prompts reserve nothing and add no network requests. Inspect
+dependencies before claiming, and split large tasks into bounded deliverables.
+
+After **five continuous idle minutes**, a
 participant with no owned unfinished tasks receives a notice to inspect the
 latest batch. A working participant can also receive one when fresh native
 child counts and an explicitly configured quota/concurrency budget show spare
@@ -2793,7 +2989,11 @@ guides load the workflow an agent needs. Install them with `collab skills instal
 Agents can publish selected skills with `collab skills publish PATH`, discover
 metadata with `collab skills shared`, inspect with `collab skills show ID`, and
 withdraw their own entry. Shared text is never installed or executed automatically.
-`collab capacity --json` estimates additional native teammates only when the
+Each participant's installed skill names are shared by default (`collab skills
+peers`; `collab config share_skill_list false` opts out), and `collab skills ask
+SKILL --to NAME` requests a run that only the receiver's human can `accept`.
+Up to two native teammates is the default when independent work exists.
+`collab capacity --json` estimates additional native teammates beyond that only when the
 concurrency, active count, fresh quota and per-task budget are known.
 [Capability and capacity guide](docs/skills-and-capacity.md).
 
@@ -2828,3 +3028,14 @@ no longer impose a model cooldown; `collab config worker_turn_gap 5` governs
 actual model calls, while existing attempt budgets and retries remain in force.
 Provider call duration still contributes to reply time. See
 [worker behavior](docs/conversation-worker.md) for the delivery model.
+
+### Shared public tunnel
+
+One machine proxy can serve every hosted session through one tunnel: sessions
+receive `/s/<id>` links under the shared domain. It is the default from 2.2.0
+(`proxy` = `auto`); `collab config proxy off`, or `collab host --tunnel own`
+for one session, keeps a hub on its own tunnel. A session that served the bare
+domain with its own tunnel before keeps it automatically, so the links handed
+out then still reach it; `collab host --primary` asks for it explicitly, and a
+session refused it is told. See [proxy hosting
+and migration](docs/proxy-hosting.md).