@loompad/cli 1.2.2 → 1.2.4

package/CHANGELOG.md

@@ -7,6 +7,48 @@ 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.
+
+### Added
+
+- **Team auto-orchestration: two people, one goal, both machines.** With a teammate's Loom running as a shared runner (`loom runner start --shared`, and `runners.shared` in the repo's `loom.team.json`), the goal you start splits across both of you: your orchestrator gets their agents as `team:<agent>` workers, a task sent to one is claimed by their runner on its own and run with *their* agent in a fresh clone, and its commits come back through origin into your goal's integration branch — still one PR, from your machine. `loom orchestrate --solo` keeps a goal local. A task no teammate's machine claims within 10 minutes goes back to the orchestrator to hand to someone else. Hub jobs gain a `task` kind (migration 0012).
+- **Simple mode, and it's the default.** A project opens on five plain tabs — Chat, Team, Agents, Board, Memory — and a composer that's just a box, the agent and Plan. No Orchestra or Crew tabs, no Insights metrics, no terminal, console, browser or right-hand panel, no model, permission or context chips, no cost meter or baton in the status bar, no MCP/skills menu; ⌘K and the menu shortcuts leave those out too, and a stray link to one says where it is instead of half-opening it.
+- **Developer mode** (Settings → Preferences → Mode) turns every one of those back on, instantly and per device. Nothing was removed — it's all where it was.
+- `loom memory:repair --dry-run` shows each memory it would change, before → after, and writes nothing (#326).
+- `loom crew status --json`: crews, goals and every card with its id, stage, touches and hold (#329).
+
+### Security
+
+- **Hub hardening (migration 0012).** Presence rows get an opaque key, so a disconnect no longer broadcasts another team's repo names to every signed-in subscriber (Realtime skips RLS on deletes); a member can no longer overwrite a teammate's key envelope; the membership helpers aren't callable by anonymous users; stale presence, expired leases and invites, and feed older than 90 days are pruned hourly.
+
+### Fixed
+
+- **`loom runner stop` really stops taking work.** A stopped runner still claimed a job the hub pushed to it; it now takes nothing new until it's started again.
+- Simple mode no longer shows Developer vocabulary: the chat's handoff chip drops the word "baton" (and the opening hand-out from nobody), and the Agents tab hides the baton and permission badges.
+- The Verified card quoted an agent's claim with its raw `**`/backticks; it quotes the words.
+- A workspace tab could fail to switch when the window wasn't painting (backgrounded), because its crossfade never ran; the click now switches it regardless.
+- **`memory:repair` now shows in `loom memory` and briefings** (#325). A decision is kept twice: an event (the record) and a memory (the live copy). The repair fixed the memory, but the Memory view and every handoff briefing read the record, so the old text stayed. They now read the live copy.
+- **A crew card no longer loops on its own lease** (#327). Codex reports edits by absolute path inside the card's worktree, and leases are repo-relative globs, so every edit looked out of bounds. The card re-held within a minute of each `crew overlap`, and the builder never ran a turn. Paths are now made repo-relative before matching.
+- **Crew checkouts follow orchestra's** (#328). A project on another disk keeps them in `.loom-worktrees` beside it, not on the internal disk; `orchestra.worktreeDir` decides for both. A checkout that already exists stays where it is.
+- **`crew status` shows card ids** (#329), plus a hint per failed card (`loom crew accept --card <id>`). A lease hold now points at `crew overlap` rather than `crew say`. The goal's `failed` event lists `failedCards`.
+
+
 ## [1.2.2] — 2026-10-18
 
 The Team tab and GitHub sign-in, and everything a third stress test (5 projects at once, restarts mid-run) found.

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

@@ -1506,6 +1506,7 @@ program
     .option("--plan", "plan mode: write the plan as markdown specs under plans/<run>/ that any agent can pick up")
     .option("--max-usd <n>", "stop this goal when it has spent this much, and say so")
     .option("--race", "race: every worker takes the whole goal in its own worktree; pick one with orchestra:apply <run> --task race-<agent>")
+    .option("--solo", "keep every task on this machine, even when teammates' runners could take some")
     .option("--no-watch", "start it and return instead of following it to the end")
     .action(async (goal, opts) => {
     const client = await ensureDaemon();
@@ -1520,7 +1521,11 @@ program
             ...(opts.plan ? { plan: true } : {}),
             ...(opts.maxUsd ? { maxUsd: Number(opts.maxUsd) } : {}),
             ...(opts.race ? { race: true } : {}),
+            ...(opts.solo ? { team: false } : {}),
         });
+        const mates = run.workers.filter((w) => w.startsWith("team:"));
+        if (mates.length)
+            console.log(pc.dim(`  teammates' machines can take tasks too: ${mates.join(", ")}`));
         console.log(run.race
             ? `${pc.magenta("🏁")} ${pc.bold(run.id)} started — ${run.workers.join(", ")} racing on the same goal`
             : `${pc.magenta("🎼")} ${pc.bold(run.id)} started — ${pc.bold(run.orchestrator.agent)} orchestrating ` +
@@ -1855,12 +1860,23 @@ program
     .option("--card <id>", "overlap: held card id; accept: the failed card to take as it stands")
     .option("--decision <decision>", "overlap: narrow, wait:<goal>, or proceed:<reason>")
     .option("--touches <globs>", "overlap: comma-separated revised paths")
+    .option("--json", "status: machine-readable")
     .action(async (action, args, opts) => {
     const client = await ensureDaemon();
     const project = await currentProject(client);
     const a = (action ?? "status").toLowerCase();
     const words = (args ?? []).join(" ").trim();
     const { crews, templates } = await client.crews(project.id);
+    if (a === "status" && opts.json) {
+        // every crew, its goal and each card with its id — what accept/overlap take (#329)
+        const pick = opts.crew ? crews.filter((c) => c.id === opts.crew || c.name === opts.crew) : crews;
+        console.log(JSON.stringify({ crews: pick.map((c) => ({ id: c.id, name: c.name, busy: Boolean(c.busy), teammates: c.teammates,
+                goal: c.state?.goal ? { id: c.state.goal.id, status: c.state.goal.status, text: c.state.goal.text, branch: c.state.goal.branch,
+                    question: c.state.goal.question ?? null, costUsd: c.state.goal.costUsd ?? null,
+                    cards: (c.state.goal.cards ?? []).map((k) => ({ id: k.id, title: k.title, stage: k.stage, builder: k.builder ?? null,
+                        touches: k.touches ?? [], blockedBy: k.blockedBy ?? [], error: k.error ?? null, hold: k.teamHold ?? k.hold ?? null })) } : null })) }, null, 2));
+        return;
+    }
     if (a === "create") {
         const [first, ...rest] = args ?? [];
         const template = first && templates.includes(first.toLowerCase()) ? first.toLowerCase() : "ship";
@@ -1878,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") {
@@ -1920,10 +1941,16 @@ function printCrew(c) {
     console.log(`  ${color(g.status)} ${g.text.split("\n")[0].slice(0, 80)} ${pc.dim(g.branch)}`);
     for (const card of g.cards ?? []) {
         const m = card.stage === "done" ? pc.green("✓") : card.stage === "failed" ? pc.red("✗") : card.stage === "planned" ? pc.dim("·") : pc.cyan("→");
-        console.log(`   ${m} ${card.title}${card.builder ? pc.dim(` ${card.builder}`) : ""}${card.stage !== "done" && card.stage !== "planned" ? pc.dim(` [${card.stage}]`) : ""}${card.error ? pc.red(` ${card.error.slice(0, 80)}`) : ""}`);
+        console.log(`   ${m} ${pc.dim(card.id)} ${card.title}${card.builder ? pc.dim(` ${card.builder}`) : ""}${card.stage !== "done" && card.stage !== "planned" ? pc.dim(` [${card.stage}]`) : ""}${card.error ? pc.red(` ${card.error.slice(0, 80)}`) : ""}`);
     }
+    // a lease hold is settled with overlap (widen or narrow the card's paths), not by answering it
+    const leaseHold = (g.cards ?? []).find((k) => k.teamHold?.kind === "decide");
     if (g.question)
-        console.log(pc.yellow(`  ${g.question.teammate} asks: ${g.question.text}`) + pc.dim("  (loom crew say \"…\")"));
+        console.log(pc.yellow(`  ${g.question.teammate} asks: ${g.question.text}`) + pc.dim(leaseHold
+            ? `  (loom crew overlap --card ${leaseHold.id} --decision "proceed: <why>" --touches "<paths>")`
+            : "  (loom crew say \"…\")"));
+    for (const k of (g.cards ?? []).filter((x) => x.stage === "failed"))
+        console.log(pc.dim(`  take ${k.id} as it stands: loom crew accept --card ${k.id}`));
     if (g.status === "awaiting_approval")
         console.log(pc.dim("  loom crew approve — or loom crew say \"…\" to change the plan"));
     if (g.status === "completed" && !g.applied)
@@ -1933,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)")
@@ -1949,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);
@@ -3166,10 +3211,17 @@ program
 program
     .command("memory:repair")
     .description("mend decisions recorded before 1.2.1 whose underscores and paths were stripped, from the planner's own words")
-    .action(async () => {
+    .option("--dry-run", "show what would change, and change nothing")
+    .action(async (opts) => {
     const client = await ensureDaemon();
     const project = await currentProject(client);
-    const { repaired, checked } = await client.repairDecisions(project.id);
+    const { repaired, checked, changes } = await client.repairDecisions(project.id, { dryRun: opts.dryRun });
+    if (opts.dryRun) {
+        for (const c of changes ?? [])
+            console.log(`${pc.dim(c.id)}\n  ${pc.red("- " + c.before)}\n  ${pc.green("+ " + c.after)}`);
+        console.log(repaired ? pc.yellow(`would mend ${repaired} of ${checked} review decisions — nothing written (run without --dry-run to apply)`) : pc.dim(`nothing to mend among ${checked} review decisions`));
+        return;
+    }
     console.log(repaired ? pc.green(`✓ mended ${repaired} of ${checked} review decisions`) : pc.dim(`nothing to mend among ${checked} review decisions`));
 });
 program