@loompad/cli 1.2.2 → 1.2.4

package/docs/release-notes/v1.2.3.md

@@ -0,0 +1,29 @@
+## Loom 1.2.3: two people, one goal, both machines
+
+### Team auto-orchestration
+- **A goal splits across your teammates' machines on its own.** When a teammate's Loom is a shared runner, your orchestrator sees their agents as `team:codex`, `team:opencode` and so on. Self-contained tasks go to them; tightly coupled ones stay with you.
+- **Nobody on their side clicks anything.** Their runner claims the task, runs it with **their** agent in a fresh clone (their subscription, their limits) and pushes the result back.
+- **A teammate who goes offline doesn't stall you.** A task nobody takes within 10 minutes goes back to your orchestrator, which hands it to someone else.
+- **Still one PR.** Your Loom merges each teammate's task into the goal's integration branch next to your own, checks what it touched against the task's lease, and opens one PR from your machine.
+- Set it up once:
+  - in the repo: `{ "runners": { "shared": true } }` in `loom.team.json`;
+  - each teammate: `loom runner start --shared`;
+  - then `loom orchestrate "<goal>"` as usual, or `--solo` to keep a goal on your machine.
+
+### Simple mode, by default
+- A project opens on five plain tabs: **Chat, Team, Agents, Board, Memory**. The composer is just a box, the agent and Plan.
+- **Developer mode** (Settings → Preferences → Mode) brings back the rest: Orchestra, Crew, Insights, the terminal, console, browser, right-hand panel, and the model, permission and cost chips.
+- No Developer vocabulary leaks into Simple mode: no "baton" labels, no permission badges.
+
+### Safer team hub
+- When a teammate disconnects, the hub no longer broadcasts their repo names to signed-in users of other teams.
+- A teammate can't replace another member's encryption key envelope; only the owner can.
+- Old presence, expired leases and invites, and team activity older than 90 days are cleaned up hourly.
+
+### Fixes from the fourth field round
+- `loom runner stop` really stops: a stopped runner no longer takes a job the hub pushes to it.
+- `loom memory:repair` now shows up in `loom memory` and in what agents are briefed with; add `--dry-run` to preview it.
+- A crew card no longer gets stuck asking about its own files.
+- Crew checkouts live beside the project on an external disk, like orchestra's.
+- `loom crew status` shows card ids, says how to accept a failed card, and has `--json`.
+- The Verified card quotes agents' words without raw markdown.

package/docs/release-notes/v1.2.4.md

@@ -0,0 +1,13 @@
+## Loom 1.2.4: two machines, one goal, set up in one step
+
+### Set up team auto-orchestration in one step
+- **`loom team auto`** checks whether goals can split across your teammates' machines here. It says which of their agents a goal would get, and what's missing.
+- **`loom team auto on`** does the setup:
+  - shares the project;
+  - writes `loom.team.json` if the repo has none (commit and merge it);
+  - turns on your machine's shared runner, so teammates' goals can use your agents too.
+- **The Team tab** shows the same status on a **Two machines, one goal** card, with a **Turn on** button.
+
+### Steadier on a teammate's machine
+- **A teammate's task no longer fails to commit.** Loom on their machine was saving its own end-of-turn checkpoint at the same moment and could undo the task's changes. The task's commit is now built separately, so nothing interferes.
+- **Follow-ups reach the teammate.** When your orchestrator asks a teammate's task for more ("also fix the test"), their machine now gets that request on top of its earlier work, instead of the whole task again.

package/docs/teams.md

@@ -163,6 +163,37 @@ Each goal gets a fresh clone (a fresh container when Docker runs), and agents
 get a scrubbed environment with only their logins and the token. If a goal of
 yours needs a CI fix and you've been offline 15 minutes, your runner takes it.
 
+### Two people, one goal: team auto-orchestration
+
+When teammates' Looms are shared runners, a goal you start doesn't stay on your
+machine. Your orchestrator sees each teammate's agents as `team:<agent>` workers
+(`team:codex`, `team:opencode`, …) and splits the goal across both machines:
+self-contained tasks go to a teammate, tightly coupled ones stay with you. Nobody
+on their side clicks anything.
+
+`loom team auto` checks it's ready and says what's missing; `loom team auto on` does the
+setup below for you (the Team tab's **Turn on** is the same thing).
+
+```bash
+# once, in the repo: let teammates' runners take its work (reviewed like any policy change)
+echo '{ "runners": { "shared": true } }' > loom.team.json
+# each teammate, once: their daemon takes tasks with their own agents
+loom runner start --shared
+# you: start a goal as usual — teammates' agents are in it when their runners are online
+loom orchestrate "Add rate limiting and its admin page"
+loom orchestrate "…" --solo   # keep this one on your machine
+```
+
+How a task travels: Loom pushes the task's starting commit to
+`refs/loom/run/<run>/<task>-base` on origin and posts a `task` job on the hub. The
+first teammate's runner with that agent claims it, runs it in a fresh clone with
+**their** agent (their subscription, their limits), commits, and pushes to
+`refs/loom/run/<run>/<task>`. Your Loom fetches it, merges it into the goal's
+integration branch next to your own tasks, and checks what it touched against the
+task's lease. The goal still lands as **one PR** from your machine. A task no
+teammate finishes within two hours fails back to your orchestrator, which can
+reassign it.
+
 ## 7. Deploys and release notes
 
 `loom team deploys` lists deployments; results show in the team feed, and a

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loompad/cli",
-  "version": "1.2.2",
+  "version": "1.2.4",
   "description": "Loom — local-first control plane for coding agents: one CLI, shared memory, baton handoffs and routes across Claude Code, OpenCode, and friends.",
   "type": "module",
   "license": "MIT",