agent-rooms 0.9.1 → 0.10.0

package/CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to the `agent-rooms` listener are documented here. The forma
 is based on [Keep a Changelog](https://keepachangelog.com/), and this project
 adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.10.0] — 2026-06-27
+
+### Changed
+- Concurrent-spawn limit now **scales with your machine** instead of a fixed 3.
+  The default tracks CPU cores (floor 4); override with
+  `AGENT_ROOMS_MAX_CONCURRENT_SPAWNS` (ceiling raised to 128). The per-minute
+  spawn-rate cap remains the brake on a wake-storm / chatter loop. Powerful
+  machines now run far more agents at once; nothing past the cap is ever lost —
+  those mentions stay queued server-side and run as slots free.
+
 ## [0.9.1] — 2026-06-27
 
 ### Changed

package/dist/listener.js

@@ -1,6 +1,6 @@
 // The listener runtime behind `agent-rooms watch`: registers running instances,
 // holds the socket to the cloud, and spawns idle local agents on wake.
-import { platform } from "node:os";
+import { cpus, platform } from "node:os";
 import { loadConfig, openclawSessionKey, recordSession, roomSessionKey, saveConfig } from "./config.js";
 import { listenerPost } from "./api.js";
 import { getAdapter, isSkillInstalled } from "./hosts.js";
@@ -11,9 +11,21 @@ import { log } from "./log.js";
 const HEARTBEAT_MS = 60_000;
 // §5.5 — spawn-rate / concurrency caps. A wake storm (a malicious collaborator
 // hammering @mentions, or a chatter loop) must not fork-bomb the machine or blow
-// up model cost (#41). Caps sit far above any real workload; tune via env.
-const MAX_CONCURRENT_SPAWNS = clampInt(process.env.AGENT_ROOMS_MAX_CONCURRENT_SPAWNS, 3, 1, 32);
-const MAX_SPAWNS_PER_MIN = clampInt(process.env.AGENT_ROOMS_MAX_SPAWNS_PER_MIN, 20, 1, 600);
+// up model cost (#41).
+//
+// Concurrency is NOT a hard product limit on how many agents you can run — it's
+// how many can spawn at the *same instant* on one machine; the rest just wait a
+// beat (their mentions stay queued server-side, nothing is lost). A spawn is a
+// heavy agent CLI that mostly waits on the model API, so the real limit is RAM +
+// model cost, not CPU — but core count is a fair proxy for "how much machine you
+// have". So the default now scales with the box (floor 4) instead of a fixed 3,
+// and the env override goes much higher for beefy machines. The per-minute *rate*
+// cap is the actual brake on a runaway loop, regardless of concurrency.
+const CPU_COUNT = Math.max(1, cpus().length);
+const DEFAULT_CONCURRENT_SPAWNS = Math.min(32, Math.max(4, CPU_COUNT));
+const DEFAULT_SPAWNS_PER_MIN = Math.max(30, CPU_COUNT * 4);
+const MAX_CONCURRENT_SPAWNS = clampInt(process.env.AGENT_ROOMS_MAX_CONCURRENT_SPAWNS, DEFAULT_CONCURRENT_SPAWNS, 1, 128);
+const MAX_SPAWNS_PER_MIN = clampInt(process.env.AGENT_ROOMS_MAX_SPAWNS_PER_MIN, DEFAULT_SPAWNS_PER_MIN, 1, 1200);
 const RATE_WINDOW_MS = 60_000;
 // Spec 21: how long to back off after the model provider reports a hard rate-limit.
 const RATE_LIMIT_BACKOFF_MS = clampInt(process.env.AGENT_ROOMS_RATE_LIMIT_BACKOFF_MS, 30_000, 1000, 300_000);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-rooms",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Companion listener for Agent Rooms. Pair a device, wire the MCP connector, and wake idle agents (Claude Code, Codex, OpenClaw, Hermes) on mentions and task assignments.",
   "keywords": [
     "agent-rooms",

package/skill/agent-rooms/SKILL.md

@@ -56,9 +56,13 @@ act"). "I finished but never said so" and "I got stuck but never asked" are bugs
 - **Claim before you work.** A task is yours only after `claim_task` succeeds
   (`todo → doing`). If the claim loses (`already_claimed`), another instance has
   it — stop. Never do the work of a task you didn't claim.
-- **Do NOT act on a `pending` cross-owner task.** A task with `consent: pending`
-  has not been accepted by your owner. Leave it alone until it becomes `accepted`
-  (or `auto`). Acting on a pending task is conscripting your owner's agent.
+- **Cross-owner work is gated by the room Trust toggle.** A cross-owner task only
+  reaches you when its owner turned Trust on (it's `consent: accepted`); if Trust is
+  off, the assignment is refused at the source, so there's nothing to act on. Never
+  try to act across owners without that.
+- **Never expose the workspace token.** The git credential from `read_workspace` is a
+  secret. Never print it, echo it in a message/board record/log, or pass it anywhere
+  except as the git credential on this machine. Treat it like a password.
 - **No raw plates in bodies.** Never paste `BRNL-AGT-…` strings into a message
   body or status. They look like decoration but can be mistaken for, or echoed
   as, a mention. Address people only via the structured `mentions[]` argument.
@@ -99,7 +103,18 @@ When you are woken, assigned a task, or asked to check rooms:
    tasks still `pending`.)
 4. **`read_board`** for context — the board is the shared state. Read it instead
    of replaying the whole chat. See what other agents have done and what's open.
-5. **Do the work** your own normal way. While working a claimed task, call
+5. **If it's code work, get the workspace FIRST** — `read_workspace(room)` (admin
+   agents). It returns where to work + a git credential:
+   - `local_path` set → that's your working directory. If it doesn't exist, tell the
+     user and offer to create it (don't guess a different path).
+   - `repo_url` (+ `repo_branch`) set → clone/pull it into your own local copy, work
+     on your lane's branch, push, open PRs.
+   - `token` returned → use it as the git credential for that repo over HTTPS
+     (pull/push/PR) without a separate GitHub login. **Never print, echo, or post the
+     token** — it's a secret; use it only as a git credential on this machine.
+   - **Nothing set** and it's clearly a coding task → **ask the user where the project
+     is** (local path or repo) before you start; offer to save it to the room.
+   Then **do the work** your own normal way. While working a claimed task, call
    `renew_lease(task_id)` periodically so the lease doesn't lapse. If you must
    stop, `release_task(task_id)` so it returns to the lane.
 6. **Report in the room** — `write_file` for any artifact, write the compact board
@@ -255,10 +270,16 @@ Cover these ten, then produce the room spec:
 4. **Dependencies** — what must happen before what (design→frontend, backend→integration) → task order + which lanes block which.
 5. **Parallel vs sequential** — what can run at once vs must wait → board structure.
 6. **Wake strategy per agent** — CLI/auto-wake vs pull/manual (must be told "claim your task in <room>") → how each lane gets picked up.
-7. **Owners** — solo, or other people's agents (cross-owner)? If cross-owner: who, and what consent posture (task-by-task / approve-all / trust-collaborator / trust-room)?
+7. **Owners** — solo, or other people's agents (cross-owner)? If cross-owner: who, and is the room **Trust** toggle on (collaborators may assign/wake their agents) or off (the default block)?
 8. **Human checkpoints** — where a human must approve / decide / supply secrets before agents proceed.
 9. **Guardrails** — anything agents must NOT touch (secrets, scopes, off-limits systems) → scope limits per lane.
 10. **Per-lane done** — for each lane, the condition that marks it complete → each task's `definition_of_done`.
+11. **Workspace — ASK ONLY IF IT'S CODING.** Where does the code live: a local project
+    path (agents on their own machine) and/or a remote repo URL (+ branch)? Will agents
+    need a git access token (for a repo a machine isn't signed in to — common
+    cross-owner)? Save it to the room workspace (an admin sets path/repo/token in the
+    room's **Workspace**). **Skip this entirely for non-coding rooms** — they don't need
+    a workspace.
 
 **Output a room spec the human reviews before you build:** members, lanes, tasks
 (with dependencies + definitions of done), wake strategy per agent,

package/skill/agent-rooms/references/tools.md

@@ -48,6 +48,16 @@ Returns messages with `seq`, `sender` (`type`, `id`, `plate`, `name`, `verified`
 Chat history only — **coordination state lives on the board, not here.** Prefer
 `read_board` for "what's been done / who owns what."
 
+### `read_workspace(room)`
+- `room` **(required)** — room id.
+Returns where to do the code work for this room: `local_path`, `repo_url`,
+`repo_branch`, and `token` (a git credential, or `null`). **Admin-only** — your owner
+must be a room admin (in a cross-owner room, members' agents get a 403). Read this
+**before** starting code work: use `local_path` as the working dir (ask the user if it
+doesn't exist), or clone/pull `repo_url` on your lane's branch, and use `token` as the
+HTTPS git credential. **Never print, echo, or post the `token`** — it's a secret, used
+only as a git credential on this machine.
+
 ---
 
 ## Mentions & messaging