@loompad/cli 1.2.1 → 1.2.3

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

@@ -0,0 +1,39 @@
+## Loom 1.2.2: Teams front and centre, and Loom that survives a restart
+
+### Teams get their own tab, and you sign in with GitHub
+- **A Team tab**, right after Chat. Teams used to sit at the bottom of Agents. Signed out, the tab shows what Loom Teams does and one **Sign in with GitHub** button. Once you're on a team, it shows:
+  - members, with their GitHub pictures;
+  - an **Invite** button;
+  - who's working on what, and which files they're touching;
+  - the team's activity and costs.
+- **Loom Desktop asks you to sign in with GitHub** when it opens. "Continue without an account" is right there, since Loom works alone; the account is for Teams.
+- **Invite works.** It said "admin only" in Desktop, because the window signed in like a phone. Desktop now holds the owner's session.
+- **Accounts are GitHub-only**, enforced by the hosted database. An email sign-up could otherwise claim someone else's GitHub name.
+- **Agents shows this project only.** Other projects are on the home screen.
+
+### Survives a restart
+- **Councils resume.** Use `loom council:resume`, or Resume on the card. A council picks up at the stage it stopped at, keeping its plan, reviews and decisions.
+- **Night shifts stay in order after a restart.** A queued task is sent once and never on top of a running turn. The report waits until the work is really done.
+- **`loom up --restart` leaves Loom Desktop's daemon alone**, and windows refresh themselves when the daemon restarts.
+
+### Honest costs and budgets
+- **The cold-session warning prices what you'll really pay.** It learns from that agent's own past turns: it said $0.34 where the real cost was $6.03, and now it says about $4.80. In a terminal it asks before sending.
+- **A turn that would cross an agent's daily budget doesn't start.**
+
+### Crews and reviews
+- **Crews:**
+  - Fixing a merge conflict no longer uses up a card's review rounds.
+  - A failed card has **Accept it anyway**: its work is merged as it is, and the cards waiting on it run.
+- **Reviews:**
+  - A review waits for a busy reviewer instead of failing.
+  - A reviewer that has never finished one is named up front.
+  - A reviewer that runs out of time is stopped, process and all.
+
+### Smaller things
+- A shift or council starting on uncommitted edits tells you, and points to Rewind.
+- Files an agent changed through the shell are counted as edits.
+- `loom memory:repair` fixes decisions recorded before 1.2.1 with their underscores stripped.
+- `loom clients --prune` clears out paired devices that never came back.
+- `loom projects --json` and `loom status --json` exist, and `loom watch --json` is clean JSON.
+- `loom doctor` and `loom agents` no longer call a signed-out agent ready.
+- The window's "N working" matches `loom status`.

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/teams.md

@@ -163,6 +163,34 @@ 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.
+
+```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.1",
+  "version": "1.2.3",
   "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",