@loompad/cli 1.2.3 → 1.2.4

package/CHANGELOG.md

@@ -7,6 +7,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.4] — 2026-10-22
+
+Team auto-orchestration, set up in one step and steadier on a teammate's machine.
+
+### Added
+
+- **`loom team auto` — two machines, one goal, set up in one step.** `loom team auto` says whether team auto-orchestration is ready in this project, which teammates' agents a goal would get, and what's missing; `loom team auto on` shares the project, writes `loom.team.json` with `runners.shared` when the repo has none (commit and merge it), and turns on this machine's shared runner. The Team tab shows the same as a **Two machines, one goal** card with a **Turn on** button.
+
+### Fixed
+
+- **A teammate's task could still fail to commit on their machine.** The clone's own Loom takes its end-of-turn checkpoint in the git index at the same moment the task commits, and could undo the task's staging ("nothing to commit"). The runner now builds the task's commit in a private index, so nothing else in the clone can disturb it.
+- `loom crew status` in a project with several crews said "which crew?" instead of listing them; it lists every crew unless you name one.
+- **A follow-up to a teammate's task re-ran the original prompt.** When the orchestrator sent a follow-up ("also fix the test"), the teammate's machine got the task from scratch. It now gets the follow-up, on top of the first attempt's work, with the original task for context.
+
 ## [1.2.3] — 2026-10-22
 
 Teams that work together on their own: one goal splits across teammates' machines. Plus Simple mode, hub hardening, and the fourth field round.

package/README.md

@@ -1560,6 +1560,16 @@ loom team                   # who's doing what, right now
 - **Worker commits carry `Loom-Goal`, `Loom-Task`, `Loom-Agent` and `Loom-Member`
   trailers.** `git log` alone tells you which goal, task and agent wrote a line.
 
+**Two people, one goal — the agents split it themselves.** When teammates turn
+on team auto-orchestration (`loom team auto on`, or **Turn on** in the Team tab),
+a goal you start splits across both machines. Your orchestrator gets their agents
+as `team:codex`, `team:opencode`…; a task sent to one is claimed by their Loom on
+its own, run with **their** agent and subscription, and merged back into your
+goal's branch — still one PR. A teammate who goes offline doesn't stall you: an
+unclaimed task returns to your orchestrator after 10 minutes. `loom team auto`
+says what's missing; `loom orchestrate "…" --solo` keeps a goal on your machine.
+See [docs/teams.md](docs/teams.md#two-people-one-goal-team-auto-orchestration).
+
 **Phase 2 (stop colliding) is built too:**
 - **Declaring touches.** On a team project, every orchestra task declares the files
   it will `touch`, and Loom takes a lease on them.

package/dist/cli/index.js

@@ -1894,12 +1894,17 @@ program
         console.log(pc.dim(`no crews here yet — loom crew create [${templates.join("|")}] [name]`));
         return;
     }
+    // status shows every crew unless one is named; everything else needs to know which
+    if (a === "status" && !opts.crew) {
+        for (const c of crews)
+            printCrew(c);
+        return;
+    }
     const crew = opts.crew ? crews.find((c) => c.id === opts.crew || c.name === opts.crew) : crews.length === 1 ? crews[0] : undefined;
     if (!crew)
         throw new Error(`which crew? --crew ${crews.map((c) => c.id).join(" | ")}`);
     if (a === "status") {
-        for (const c of opts.crew ? [crew] : crews)
-            printCrew(c);
+        printCrew(crew);
         return;
     }
     if (a === "diff") {
@@ -1955,7 +1960,7 @@ function printCrew(c) {
 }
 program
     .command("team [action] [args...]")
-    .description("Loom Teams: status | signin [hub] | create <name> | invite | join <link> | share | unshare | brain [inbox|promote|resolve|correct|trust|private] | landing | doctor [fix] | adopt <pr> | deploys | release-notes <since> | webhook [--repo r] [--install] | remove <github> | leave")
+    .description("Loom Teams: status | auto [on] | signin [hub] | create <name> | invite | join <link> | share | unshare | brain [inbox|promote|resolve|correct|trust|private] | landing | doctor [fix] | adopt <pr> | deploys | release-notes <since> | webhook [--repo r] [--install] | remove <github> | leave")
     .option("--github <login>", "your GitHub login (defaults to the gh CLI's)")
     .option("--repo <owner/name>", "webhook: which repo (defaults to this project's)")
     .option("--install", "webhook: create it on the repo with gh (needs repo admin)")
@@ -1971,6 +1976,24 @@ program
     try {
         if (a === "status")
             return void printTeam(await client.team());
+        if (a === "auto") {
+            // team auto-orchestration: your goals split across teammates' machines, theirs across yours
+            const project = await currentProject(client);
+            const st = await client.teamAuto(project.id, arg === "on");
+            if (st.wrotePolicy)
+                console.log(`${pc.green("✓")} wrote loom.team.json (runners.shared) — commit and merge it; policy is reviewed like code`);
+            const mark = (ok) => (ok ? pc.green("✓") : pc.dim("·"));
+            console.log(`${mark(st.shared)} project shared with your team`);
+            console.log(`${mark(st.policyShared)} repo policy lets teammates' runners take its work`);
+            console.log(`${mark(st.myRunner.running && st.myRunner.shared)} your runner is on and shared (teammates' goals can use your agents)`);
+            const on = st.teammates.filter((t) => t.online);
+            console.log(`${mark(on.length > 0)} teammates' runners online: ${on.length ? on.map((t) => `${t.github} (${t.kinds.join(", ")})`).join(", ") : "none yet"}`);
+            if (st.ready)
+                console.log(`\n${pc.green("ready")} — goals you start get ${st.workers.join(", ")} as workers. ${pc.dim("loom orchestrate \"…\" (--solo to keep one local)")}`);
+            else
+                console.log(`\n${pc.yellow("not yet")} — ${st.missing.join("; ")}`);
+            return;
+        }
         if (a === "signin") {
             const { hostedHubUrl, hostedSupabaseUrl, publishableKeyFor } = await import("../core/hosted.js");
             const supabaseUrl = hostedSupabaseUrl(arg);