@dirwin517/bot-farm 0.1.0

package/test/handoff.mjs

@@ -0,0 +1,228 @@
+// Open questions travel with a handoff instead of stopping the line, unless
+// the stage says to wait; the operator can let a held stage go on with answers.
+import { spawn as spawnProc, execFile } from "node:child_process"
+import { promisify } from "node:util"
+import { mkdtemp, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { Supervisor } from "../src/supervisor.mjs"
+import { startServer } from "../src/server.mjs"
+
+const run = promisify(execFile)
+const mock = spawnProc(process.execPath, [new URL("./mock-opencode.mjs", import.meta.url).pathname], { stdio: "ignore" })
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+let failed = 0
+const ok = (c, m) => (c ? console.log("  ok  " + m) : (failed++, console.error("  FAIL " + m)))
+const repo = await mkdtemp(join(tmpdir(), "ho-"))
+await run("git", ["init", "-q", "-b", "main"], { cwd: repo })
+await writeFile(join(repo, "a"), "x")
+await run("git", ["add", "."], { cwd: repo })
+await run("git", ["-c", "user.email=t@t", "-c", "user.name=t", "commit", "-qm", "i"], { cwd: repo })
+const home = await mkdtemp(join(tmpdir(), "hoh-"))
+await sleep(600)
+const sup = new Supervisor({ url: "http://127.0.0.1:4096", statePath: join(home, "m.json"), registryPath: join(home, "r.json"), mcpBase: "http://127.0.0.1:4837" })
+await sup.start()
+startServer({ supervisor: sup, port: 4837 })
+const texts = async (id) => (await sup.client.messages(id, { limit: 200 })).filter((m) => (m.info ?? m).role !== "assistant").flatMap((m) => (m.parts ?? []).map((p) => p.text ?? ""))
+const idle = async (id) => { await sup.client.interrupt(id); sup.store.get(id).setStatus("idle") }
+
+console.log("open questions do not stop the line")
+const r = await sup.pipelines.start({ pipeline: "story", repo, branch: "feat/a", story: "DE238: DELETE should 409 when a FRID exists", title: "A" })
+await sleep(300)
+await idle(r.sessions.dev)
+await sup.pipelines.complete(sup.tasks.get(r.taskIds.analyse), { summary: "Criteria written.", acceptance_criteria: ["409 on FRID"], open_questions: ["Which FRID statuses count?", "Is soft-delete in scope?"] })
+await sleep(300)
+ok(sup.tasks.get(r.taskIds.analyse).status === "done", "the stage is done")
+ok(sup.tasks.get(r.taskIds.build).status === "active", "and the next bot picks up its card straight away")
+const dev = (await texts(r.sessions.dev)).find((t) => t.includes("[botfarm] task"))
+ok(dev?.includes("Which FRID statuses count?") && dev.includes("Settle them"), "carrying the open questions with it")
+ok(dev?.includes("Finished analyse: Criteria written."), "the handoff notice rides along with the card")
+ok(!(await texts(r.sessions.dev)).some((t) => t.startsWith("[botfarm]") && t.includes("Finished analyse") && !t.includes("[botfarm] task")), "instead of waking the bot on its own")
+ok(!(await texts(r.sessions.qa)).some((t) => t.includes("Finished analyse")), "and later stages are not woken by it")
+
+console.log("\na stage can choose to wait")
+const r2 = await sup.pipelines.start({ pipeline: "story", repo, branch: "feat/b", story: "US1: another", title: "B" })
+const run2 = sup.pipelines.run(r2.id)
+run2.def.stages[0].hold_on_questions = true
+sup.db.put("runs", run2)
+await sleep(300)
+await idle(r2.sessions.dev)
+await sup.pipelines.complete(sup.tasks.get(r2.taskIds.analyse), { summary: "Written.", acceptance_criteria: ["x"], open_questions: ["Which API version?"] })
+await sleep(300)
+ok(sup.tasks.get(r2.taskIds.analyse).status === "review", "a holding stage waits in review")
+ok(sup.tasks.get(r2.taskIds.build).status === "blocked", "and the next stage has not started")
+const res = await fetch(`http://127.0.0.1:4837/api/tasks/${r2.taskIds.analyse}/continue`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ note: "Use v1 only." }) })
+ok(res.ok, "you can let it continue")
+await sleep(300)
+ok(sup.tasks.get(r2.taskIds.build).status === "active", "which starts the next bot")
+const dev2 = (await texts(r2.sessions.dev)).find((t) => t.includes("[botfarm] task"))
+ok(dev2?.includes("The operator's answer: Use v1 only."), "with your answer in its card")
+ok(sup.rooms.rooms.get(run2.roomId).messages.some((m) => m.from === "operator" && m.text.includes("Use v1 only.")), "and in the chat")
+
+console.log("\nchatter does not wake bots whose stage has not started")
+const room = sup.rooms.rooms.get(sup.pipelines.run(r.id).roomId)
+for (let i = 0; i < 8; i++) await sup.rooms.post(room, i % 2 ? null : sup.store.get(r.sessions.dev), `message ${i}`)
+await sup.rooms.flushAll(sup.store.get(r.sessions.reviewer))
+ok((await texts(r.sessions.reviewer)).length === 0, "not even when the backlog grows")
+
+console.log("\nquestions for you come with choices")
+const tokenFor = (id) => sup.mcpUrlFor(sup.store.get(id)).split("/").pop()
+const call = async (id, name, args) => {
+  sup.mcpCalls.set(id, Date.now())
+  const res = await fetch(`http://127.0.0.1:4837/mcp/${tokenFor(id)}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }) })
+  return (await res.json()).result
+}
+const asked = await call(r.sessions.dev, "ask_human", { questions: [
+  { question: "Which FRID statuses block the delete?", options: [{ label: "Active only", description: "Expired FRIDs are ignored" }, "Active and pending"], header: "FRID" },
+  { question: "Which environments?", options: ["dev", "qa", "prod"], multiple: true },
+  { question: "Anything else I should know?" },
+] })
+ok(!asked.isError, "a bot can ask several questions at once")
+const q = sup.tasks.get(asked.structuredContent.task_id)
+ok(q.questions.length === 3 && q.questions[0].options[0].description === "Expired FRIDs are ignored" && q.questions[1].multiple, "each with its own choices, single or multiple")
+ok(q.questions[2].options.length === 0, "or none, for an open question")
+await fetch(`http://127.0.0.1:4837/api/tasks/${q.id}/answer`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ answers: [{ picked: ["Active only"], text: "" }, { picked: ["dev", "qa"], text: "prod later" }, { picked: [], text: "" }] }) })
+await sleep(200)
+const got = (await texts(r.sessions.dev)).find((t) => t.includes("your operator answered"))
+ok(got?.includes("→ Active only") && got.includes("→ dev, qa — prod later"), "your picks and your words go back together")
+ok(got?.includes("(no answer — use your judgement)"), "and a question you skipped says so")
+const one = await call(r.sessions.dev, "ask_human", { question: "Ship behind a flag?", options: ["yes", "no"] })
+ok(sup.tasks.get(one.structuredContent.task_id).questions[0].options.length === 2, "the one-question form still works")
+
+console.log("\nan agent's tools are enforced per turn")
+const prod = sup.store.get(r.sessions.product)
+prod.allowedTools = ["read", "grep", "glob", "list"]
+const sw = await sup.toolSwitches(prod)
+ok(sw && sw.bash === false && sw.edit === false && !("read" in sw) && !("grep" in sw), "everything not on its list is switched off")
+ok(await sup.toolSwitches(sup.store.get(r.sessions.qa)) === undefined, "an agent with no list keeps every tool")
+
+console.log("\nyour sign-off stage is a question too")
+for (const st of ["build", "verify", "check"]) await sup.pipelines.release(sup.tasks.get(r.taskIds[st]), "")
+const signoff = sup.tasks.get(r.taskIds.signoff)
+ok(signoff.status === "waiting" && signoff.kind === "question", "it reaches you once the chain before it is done")
+await fetch(`http://127.0.0.1:4837/api/tasks/${signoff.id}/answer`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ answers: [{ picked: ["Looks good — ship it"], text: "" }] }) })
+await sleep(200)
+ok(sup.tasks.get(signoff.id).status === "done" && sup.pipelines.run(r.id).status === "done", "answering it finishes the run")
+
+console.log("\nbots with no open cards stay quiet")
+const [devS, qaS, revS] = [r.sessions.dev, r.sessions.qa, r.sessions.reviewer].map((id) => sup.store.get(id))
+for (const b of [devS, qaS, revS]) b.setStatus("idle")
+ok(sup.pipelines.resting(qaS) && !sup.pipelines.resting(sup.store.get(r2.sessions.dev)), "a bot is resting once all its cards are done")
+const count = async (id) => (await texts(id)).length
+let n = await count(qaS.id)
+await sup.rooms.post(room, devS, `All done here, thanks @${qaS.handle} and @${revS.handle}!`)
+await sup.rooms.post(room, revS, "Great work everyone.")
+await sup.rooms.flushAll(qaS)
+ok(await count(qaS.id) === n, "thanks and sign-offs do not wake it, even at idle")
+await sup.rooms.post(room, devS, `@${qaS.handle} did the 409 test run against qa?`)
+ok(await count(qaS.id) === n + 1, "a direct question does")
+ok((await texts(qaS.id)).some((t) => t.includes("Great work everyone.") && t.includes("did the 409")), "with what it missed")
+n = await count(revS.id)
+await sup.rooms.post(room, null, "One more thing: add a changelog line.")
+ok(await count(revS.id) === n + 1, "and so does the operator")
+ok((await texts(revS.id)).some((t) => t.includes("add a changelog") && t.includes("Do not post to acknowledge")), "and the frame says not to post just to agree")
+
+console.log("\na partly done workstream can be restarted")
+const r3 = await sup.pipelines.start({ pipeline: "story", repo, branch: "feat/c", story: "DE9: restart me", title: "C" })
+await sleep(300)
+await idle(r3.sessions.dev)
+await sup.pipelines.complete(sup.tasks.get(r3.taskIds.analyse), { summary: "Criteria v1.", acceptance_criteria: ["a"] })
+await sleep(200)
+ok(sup.tasks.get(r3.taskIds.build).status === "active", "(build is under way)")
+const project3 = sup.pipelines.run(r3.id).projectId
+const before = { ...sup.pipelines.run(r3.id).sessions }
+// Same bots, from the current stage
+let out = await sup.pipelines.restart(project3, { fresh: false })
+ok(out.from === "build" && out.fresh === 0, "by default from the first unfinished stage")
+ok(sup.tasks.get(r3.taskIds.analyse).status === "done" && sup.tasks.get(r3.taskIds.analyse).handoff.summary === "Criteria v1.", "earlier stages keep their handoff")
+ok(sup.tasks.get(r3.taskIds.build).status === "active" && sup.tasks.get(r3.taskIds.verify).status === "blocked", "the stage is handed out again and the rest wait")
+// Fresh bots, from the start
+out = await sup.pipelines.restart(project3, { stage: "analyse", fresh: true })
+await sleep(300)
+const after = sup.pipelines.run(r3.id).sessions
+ok(out.fresh === 4 && Object.keys(before).every((k) => after[k] && after[k] !== before[k]), "fresh bots replace every old one")
+ok(Object.values(before).every((id) => !sup.store.get(id)), "the old sessions leave the board")
+ok(Object.values(after).every((id) => sup.store.get(id)?.directory === sup.store.get(after.product).directory), "the new ones work in the same worktree")
+ok(sup.tasks.get(r3.taskIds.analyse).status === "active" && sup.tasks.get(r3.taskIds.analyse).assignee === after.product, "the first stage goes to the new product bot")
+ok(!sup.tasks.get(r3.taskIds.analyse).handoff && sup.tasks.get(r3.taskIds.build).status === "blocked", "with the old handoff cleared")
+const room3 = sup.rooms.rooms.get(sup.pipelines.run(r3.id).roomId)
+ok(Object.values(after).every((id) => room3.members.has(id)) && Object.values(before).every((id) => !room3.members.has(id)), "the chat has the new team")
+ok((await texts(after.product)).some((t) => t.includes("You are the product analyst")), "and the new bot is briefed again")
+
+console.log("\na long opencode history does not hide the team")
+for (let i = 0; i < 210; i++) await fetch("http://127.0.0.1:4096/api/session", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ title: "old " + i, location: { directory: "/tmp/old" } }) })
+const r4 = await sup.pipelines.start({ pipeline: "story", repo, branch: "feat/d", story: "DE10: after a long history", title: "D" })
+await sup.discover()
+ok(Object.values(r4.sessions).every((id) => sup.store.get(id)), "bots beyond the first page of sessions stay on the board")
+ok(Object.values(after).every((id) => sup.store.get(id)), "including a freshly restarted team")
+
+console.log("\na workstream can be deleted when you are done")
+const r5 = await sup.pipelines.start({ pipeline: "story", repo, branch: "botfarm/delete-me", story: "DE11: throwaway", title: "E" })
+await sleep(300)
+const p5 = sup.pipelines.run(r5.id).projectId
+const wt5 = sup.projects.get(p5).worktree
+const room5 = sup.projects.get(p5).roomId
+await writeFile(join(wt5, "scratch.txt"), "unsaved")
+let pv = await (await fetch(`http://127.0.0.1:4837/api/projects/${p5}/delete`)).json()
+ok(pv.changed === 1 && pv.files.includes("scratch.txt") && pv.branchOwned && pv.bots === 4, "the dialog is told what would go, uncommitted files first")
+let del = await fetch(`http://127.0.0.1:4837/api/projects/${p5}/delete`, { method: "POST", headers: { "content-type": "application/json" }, body: "{}" })
+ok(del.status === 409 && sup.projects.get(p5), "uncommitted work stops it unless you say so")
+del = await fetch(`http://127.0.0.1:4837/api/projects/${p5}/delete`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ force: true, deleteBranch: true }) })
+ok(del.ok, "and then it goes")
+ok(!sup.projects.get(p5) && !sup.pipelines.run(r5.id) && !sup.rooms.rooms.get(room5), "the workstream, its run and its chat are gone")
+ok(sup.tasks.all({ projectId: p5 }).length === 0 && Object.values(r5.sessions).every((id) => !sup.store.get(id) && !sup.registry.get(id)), "and so are its cards and bots")
+ok(!(await run("git", ["worktree", "list"], { cwd: repo })).stdout.includes(wt5), "the worktree is removed")
+ok(!(await run("git", ["branch", "--list", "botfarm/delete-me"], { cwd: repo })).stdout.trim(), "and the botfarm branch, because you asked")
+const p4 = sup.pipelines.run(r4.id).projectId
+pv = await (await fetch(`http://127.0.0.1:4837/api/projects/${p4}/delete`)).json()
+ok(pv.branch === "feat/d" && !pv.branchOwned, "a branch you named yourself is never offered")
+await fetch(`http://127.0.0.1:4837/api/projects/${p4}/delete`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ deleteBranch: true }) })
+ok(!sup.projects.get(p4) && (await run("git", ["branch", "--list", "feat/d"], { cwd: repo })).stdout.trim(), "so it survives the delete")
+
+console.log("\nan MCP server that was down when opencode opened the worktree is retried")
+const botM = sup.store.get(Object.values(sup.pipelines.run(r3.id).sessions)[0])
+await fetch("http://127.0.0.1:4096/__mcp-down?down=1")
+await sup.refreshMcp([botM], { force: true })
+ok(botM.mcp.servers.find((m) => m.name === "local-dev")?.status === "failed" && botM.mcp.servers.find((m) => m.name === "local-dev").error, "while it is still down the bot shows it failed, with why")
+ok((await (await fetch("http://127.0.0.1:4096/__mcp-connects")).json()).some((c) => c.name === "local-dev" && c.directory === botM.directory), "and BotFarm asked opencode to connect it again")
+ok(!(await (await fetch("http://127.0.0.1:4096/__mcp-connects")).json()).some((c) => c.name === "rag" || c.name === "botfarm" || c.name === "botfarm"), "but leaves disabled servers alone")
+await fetch("http://127.0.0.1:4096/__mcp-down?down=0")
+const rc = await fetch(`http://127.0.0.1:4837/api/sessions/${botM.id}/mcp/reconnect`, { method: "POST", headers: { "content-type": "application/json" }, body: "{}" })
+ok(rc.ok && (await rc.json()).servers.find((m) => m.name === "local-dev").connected, "once it is up, Reconnect brings it back")
+
+console.log("\nworkspace config changes reach running workstreams")
+const repo6 = await mkdtemp(join(tmpdir(), "cfg-"))
+await run("git", ["init", "-q", "-b", "main"], { cwd: repo6 })
+const { mkdir: mkd, readFile: rf } = await import("node:fs/promises")
+await mkd(join(repo6, ".opencode"))
+const wsCfg = (mcp) => writeFile(join(repo6, ".opencode", "opencode.json"), JSON.stringify({ agent: { plan: { permission: { edit: "deny", "local-broad*": "allow" } } }, mcp }))
+await wsCfg({ "local-broad": { type: "remote", url: "http://localhost:3333/sse/broad", enabled: true }, rally: { type: "remote", url: "https://mcp.rallydev.com/mcp", enabled: true } })
+await writeFile(join(repo6, "a"), "x")
+await run("git", ["add", "."], { cwd: repo6 })
+await run("git", ["-c", "user.email=t@t", "-c", "user.name=t", "commit", "-qm", "i"], { cwd: repo6 })
+const r6 = await sup.pipelines.start({ pipeline: "story", repo: repo6, branch: "feat/cfg", story: "US3: config", title: "F" })
+await sleep(300)
+const p6 = sup.pipelines.run(r6.id).projectId
+const wt6 = sup.projects.get(p6).worktree
+const cfg6 = async () => JSON.parse(await rf(join(wt6, ".opencode", "opencode.json"), "utf8"))
+let c6 = await cfg6()
+ok(c6.mcp["local-broad"]?.url.includes("root=") && c6.mcp.botfarm, "the worktree starts with the workspace's MCP servers, pinned to it")
+const prodPerm = c6.agent["botfarm-product"].permission ?? {}
+ok(prodPerm["local-broad_*"] === "deny" && prodPerm["rally_*"] === "deny" && !("local-broad*" in prodPerm), "a bot limited to a few tools is denied MCP servers it does not list, even ones its base agent allows")
+await wsCfg({ rally: { type: "remote", url: "https://mcp.rallydev.com/mcp", enabled: true } })
+const disposedBefore = (await (await fetch("http://127.0.0.1:4096/__disposed")).json().catch(() => [])).length
+const rr = await fetch(`http://127.0.0.1:4837/api/projects/${p6}/refresh-config`, { method: "POST", headers: { "content-type": "application/json" }, body: "{}" })
+const rrOut = await rr.json()
+c6 = await cfg6()
+ok(rr.ok && !c6.mcp["local-broad"] && c6.mcp.rally && c6.mcp.botfarm, "Refresh tools drops a server removed from the workspace and keeps botfarm")
+ok(!("local-broad_*" in (c6.agent["botfarm-product"].permission ?? {})), "and the bots' agents are rebuilt from the new setup")
+ok(rrOut.reloaded || rrOut.pending, "then opencode re-opens the worktree, now or once the bots are idle")
+
+console.log("\nthe chat can colour a bot")
+const snap = sup.store.get(r.sessions.dev).snapshot()
+ok(/^#[0-9a-f]{6}$/.test(snap.color?.fg) && /^#[0-9a-f]{6}$/.test(snap.color?.bg), "every session carries its avatar colours")
+
+sup.stop()
+mock.kill()
+console.log(failed ? `\n${failed} CHECKS FAILED` : "\nall checks passed")
+process.exit(failed ? 1 : 0)

package/test/linked.mjs

@@ -0,0 +1,83 @@
+// Repos from anywhere in a workstream: linked to the workspace up front, or added after the fact.
+import { spawn as spawnProc, execFile } from "node:child_process"
+import { promisify } from "node:util"
+import { mkdtemp, writeFile, mkdir, stat } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { Supervisor } from "../src/supervisor.mjs"
+import { startServer } from "../src/server.mjs"
+import * as git from "../src/git.mjs"
+
+const run = promisify(execFile)
+const mock = spawnProc(process.execPath, [new URL("./mock-opencode.mjs", import.meta.url).pathname], { stdio: "ignore" })
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+let failed = 0
+const ok = (c, m) => (c ? console.log("  ok  " + m) : (failed++, console.error("  FAIL " + m)))
+const mkrepo = async (dir, file) => {
+  await mkdir(dir, { recursive: true })
+  await run("git", ["init", "-q", "-b", "main"], { cwd: dir })
+  await writeFile(join(dir, file), "x\n")
+  await run("git", ["add", "."], { cwd: dir })
+  await run("git", ["-c", "user.email=t@t", "-c", "user.name=t", "commit", "-qm", "i"], { cwd: dir })
+  return dir
+}
+const exists = (p) => stat(p).then(() => true, () => false)
+const base = await mkdtemp(join(tmpdir(), "linked-"))
+const repo = await mkrepo(join(base, "java-parent-services"), "pom.xml")
+const spt = await mkrepo(join(base, "elsewhere", "spt"), "App.java")
+const ui = await mkrepo(join(base, "elsewhere", "web-ui"), "package.json")
+const home = await mkdtemp(join(tmpdir(), "linkedh-"))
+process.env.BOT_FARM_WORKTREE_ROOT = join(home, "wt")
+await sleep(600)
+const PORT = 4849
+const sup = new Supervisor({ url: "http://127.0.0.1:4096", statePath: join(home, "m.json"), registryPath: join(home, "r.json"), mcpBase: `http://127.0.0.1:${PORT}` })
+await sup.start()
+startServer({ supervisor: sup, port: PORT })
+const api = async (path, opts = {}) => {
+  const res = await fetch(`http://127.0.0.1:${PORT}${path}`, { method: opts.method ?? "GET", headers: opts.body ? { "content-type": "application/json" } : undefined, body: opts.body ? JSON.stringify(opts.body) : undefined })
+  return { status: res.status, body: await res.json().catch(() => null) }
+}
+const prompts = async (id) => (await (await fetch("http://127.0.0.1:4096/__prompts")).json()).filter((p) => p.id === id)
+const ws = await sup.workspaces.add({ path: repo, name: "jps" })
+
+console.log("linking a repo from elsewhere to the workspace")
+let res = await api(`/api/workspaces/${ws.id}/repos`, { method: "POST", body: { path: spt } })
+ok(res.status === 200 && res.body.linked[0].path === spt && res.body.linked[0].as === "spt" && res.body.services.includes(spt), "a repo outside the workspace is linked, mounted as spt/, and ticked for new workstreams")
+res = await api(`/api/workspaces/${ws.id}/repos`, { method: "POST", body: { path: spt } })
+ok(res.status === 400 && /already linked/.test(res.body.error), "twice is refused")
+res = await api(`/api/workspaces/${ws.id}/repos`, { method: "POST", body: { path: join(base, "elsewhere") } })
+ok(res.status === 400 && /not a git repository/.test(res.body.error), "a folder that is not a repo is refused")
+const lib = (await api(`/api/workspaces/${ws.id}/library`)).body
+ok(lib.linked?.length === 1, "the library lists it for the new-workstream dialog")
+
+console.log("\na workstream takes it along")
+const r = await sup.pipelines.start({ pipeline: "story", workspace: ws.id, story: "US1: something across repos", title: "Across" })
+await sleep(400)
+const project = sup.projects.get(r.projectId)
+ok(project.worktree && await exists(join(project.worktree, "spt", "App.java")), "the workstream's worktree has spt/ in it")
+ok((await git.status(join(project.worktree, "spt"))).branch === project.branch, "on the workstream's branch")
+const first = sup.store.get(Object.values(r.sessions)[0])
+const text = (await prompts(first.id)).at(-1)?.parts?.[0]?.text ?? ""
+ok(text.includes("Repos in this worktree") && text.includes("./spt/"), "and the bots are told which repos are where")
+
+console.log("\nadding one after the fact")
+res = await api(`/api/projects/${r.projectId}/repos`, { method: "POST", body: { path: ui, as: "ui" } })
+ok(res.status === 200 && res.body.rel === "ui" && await exists(join(project.worktree, "ui", "package.json")), "a running workstream gets a worktree of another repo, mounted as ui/")
+ok((await git.status(project.worktree)).untracked === 0, "the parent repo does not see it as untracked")
+const room = sup.projects.room(r.projectId, { create: false })
+ok(room?.messages.some((m) => m.text.includes("ui/ is now in this worktree")), "the chat says so")
+ok(sup.pipelines.run(r.id).notes?.some((n) => n.topic === "Repos in this worktree" && n.text.includes("./ui/")), "and so do the team notes")
+res = await api(`/api/projects/${r.projectId}/repos`, { method: "POST", body: { path: ui } })
+ok(res.status === 400 && /already in this workstream/.test(res.body.error), "the same repo twice is refused")
+ok((await sup.workstreamRepos(sup.projects.get(r.projectId))).includes(ui), "it counts as one of the workstream's repos (for branches and delete)")
+
+console.log("\ndeleting the workstream")
+await sup.deleteWorkstream(r.projectId, { deleteBranch: true, force: true })
+ok((await git.listWorktrees(spt)).length === 1 && (await git.listWorktrees(ui)).length === 1, "the worktrees in the other repos go too")
+const branches = (await run("git", ["branch", "--list", "botfarm/*"], { cwd: ui })).stdout.trim()
+ok(!branches, "and their botfarm/ branches")
+
+sup.stop()
+mock.kill()
+console.log(failed ? `\n${failed} CHECKS FAILED` : "\nall checks passed")
+process.exit(failed ? 1 : 0)

package/test/loop.mjs

@@ -0,0 +1,168 @@
+// Plan → Code → Verify → Fail → Code → Verify → Pass: sending work back.
+import { spawn as spawnProc, execFile } from "node:child_process"
+import { promisify } from "node:util"
+import { mkdtemp, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join } from "node:path"
+import { Supervisor } from "../src/supervisor.mjs"
+import { startServer } from "../src/server.mjs"
+import { checkPipelineDoc } from "../src/pipelines.mjs"
+
+const run = promisify(execFile)
+const mock = spawnProc(process.execPath, [new URL("./mock-opencode.mjs", import.meta.url).pathname], { stdio: "ignore" })
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms))
+let failed = 0
+const ok = (c, m) => (c ? console.log("  ok  " + m) : (failed++, console.error("  FAIL " + m)))
+const repo = await mkdtemp(join(tmpdir(), "loop-"))
+await run("git", ["init", "-q", "-b", "main"], { cwd: repo })
+await writeFile(join(repo, "a"), "x")
+await run("git", ["add", "."], { cwd: repo })
+await run("git", ["-c", "user.email=t@t", "-c", "user.name=t", "commit", "-qm", "i"], { cwd: repo })
+const home = await mkdtemp(join(tmpdir(), "looph-"))
+process.env.BOT_FARM_WORKTREE_ROOT = join(home, "wt")
+await sleep(600)
+const PORT = 4847
+const sup = new Supervisor({ url: "http://127.0.0.1:4096", statePath: join(home, "m.json"), registryPath: join(home, "r.json"), mcpBase: `http://127.0.0.1:${PORT}` })
+await sup.start()
+startServer({ supervisor: sup, port: PORT })
+const api = async (path, opts = {}) => {
+  const res = await fetch(`http://127.0.0.1:${PORT}${path}`, { method: opts.method ?? "GET", headers: opts.body ? { "content-type": "application/json" } : undefined, body: opts.body ? JSON.stringify(opts.body) : undefined })
+  return { status: res.status, body: await res.json().catch(() => null) }
+}
+const prompts = async (id) => (await (await fetch("http://127.0.0.1:4096/__prompts")).json()).filter((p) => p.id === id)
+const lastText = async (id) => (await prompts(id)).at(-1)?.parts?.[0]?.text ?? ""
+const T = (id) => sup.tasks.get(id)
+const idleAll = () => { for (const s of sup.store.list()) s.setStatus("idle") }
+const token = (s) => sup.mcpUrlFor(s).split("/").pop()
+const rpc = async (s, name, args) => { sup.mcpCalls.set(s.id, Date.now()); return (await (await fetch(`http://127.0.0.1:${PORT}/mcp/${token(s)}`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "tools/call", params: { name, arguments: args } }) })).json()).result }
+
+const ws = await sup.workspaces.add({ path: repo, name: "loop" })
+const lib = await sup.pipelines.lib(ws.id)
+lib.definitions.set("tdd", { id: "tdd", title: "TDD loop", stages: [
+  { id: "plan", persona: "product", receives: [], prompt: "{{story}}" },
+  { id: "code", persona: "dev", receives: ["plan"], prompt: "Build it." },
+  { id: "verify", persona: "qa", receives: ["plan", "code"], max_rounds: 2, prompt: "Verify it." },
+] })
+lib.definitions.set("fan", { id: "fan", title: "Fan", stages: [
+  { id: "plan", persona: "product", receives: [], prompt: "{{story}}" },
+  { id: "build", persona: "dev", receives: ["plan"], split: "tasks", parallel: 2, prompt: "Build your piece." },
+  { id: "verify", persona: "qa", receives: ["build"], prompt: "Verify it." },
+] })
+for (const [k, v] of sup.pipelines.personas) if (!lib.personas.has(k)) lib.personas.set(k, v)
+
+console.log("the pipeline file")
+const bad = checkPipelineDoc({ id: "x", stages: [{ id: "a", persona: "dev" }, { id: "b", persona: "qa", send_back: ["zzz"], max_rounds: 99 }] }, lib.personas)
+ok(bad.some((p) => p.includes('"zzz"')) && bad.some((p) => p.includes("max_rounds")), "send_back and max_rounds are checked")
+
+console.log("\nCode → Verify → Fail → Code → Verify")
+const r = await sup.pipelines.start({ pipeline: "tdd", workspace: ws.id, story: "DE238: DELETE should 409 when a FRID exists", title: "Loop" })
+await sleep(300); idleAll()
+await sup.pipelines.complete(T(r.taskIds.plan), { summary: "Criteria set.", acceptance_criteria: ["409 when a FRID is active"] })
+await sleep(300); idleAll()
+const code = () => T(r.taskIds.code), verify = () => T(r.taskIds.verify)
+const dev = sup.store.get(code().assignee)
+await sup.pipelines.complete(code(), { summary: "Added the FRID check in CardService.", artifacts: ["CardService.java"] })
+await sleep(300); idleAll()
+const qa = sup.store.get(verify().assignee)
+ok(verify().status === "active" && (await lastText(qa.id)).includes("botfarm_send_back") && (await lastText(qa.id)).includes("code (@"), "the checker is told it can send work back, and to whom")
+let out = await rpc(qa, "send_back", { task_id: verify().id, to: "code", reason: "DELETE still returns 500", failures: ["FridDeleteIT.deleteWithActiveFrid: expected 409 but was 500 (CardController.java:88)"] })
+await sleep(300)
+ok(!out.isError && out.structuredContent.fix === "1 of 2", "QA sends the code back (fix 1 of 2)")
+ok(code().round === 2 && code().history?.[0]?.summary.includes("FRID check") && code().status === "active" && code().assignee === dev.id, "the code card goes back to the dev who wrote it, with the last round kept")
+ok(verify().status === "blocked" && verify().recheck?.to === "code" && verify().dependsOn.includes(code().id), "QA's card waits for the fix")
+let t = await lastText(dev.id)
+ok(t.includes("Round 2") && t.includes("expected 409 but was 500") && t.includes("Added the FRID check"), "the dev's prompt says what failed and what it handed off last time")
+const room = sup.rooms.rooms.get(r.roomId)
+ok(room.messages.some((m) => m.meta?.kind === "sendback" && m.text.includes("fix 1 of 2")), "the chat shows it was sent back")
+idleAll()
+await sup.pipelines.complete(code(), { summary: "Mapped FridActiveException to 409 in the controller advice." })
+await sleep(300); idleAll()
+ok(code().xp?.gained === 3 && code().rework === null, "a fix round earns a little XP, not a full card")
+t = await lastText(qa.id)
+ok(verify().status === "active" && verify().assignee === qa.id && t.includes("Fix 1") && t.includes("controller advice") && t.includes("Verify it again"), "the same QA bot gets its card back with the fix to verify")
+
+console.log("\nstopping the loop")
+out = await rpc(qa, "send_back", { task_id: verify().id, to: "code", reason: "DELETE still returns 500", failures: ["FridDeleteIT.deleteWithActiveFrid: expected 409 but was 500 (CardController.java:88)"] })
+ok(out.structuredContent.paused && verify().status === "review" && verify().budget?.kind === "rounds" && /same failure/.test(verify().budget.why), "the same failure twice stops and asks the operator")
+ok(code().status === "done", "and nothing was sent")
+idleAll()
+let res = await api(`/api/tasks/${verify().id}/budget`, { method: "POST", body: { action: "continue" } })
+await sleep(300)
+ok(res.status === 200 && code().round === 3 && code().status === "active", "One more round sends it after all")
+idleAll()
+await sup.pipelines.complete(code(), { summary: "Fixed the transaction boundary too." })
+await sleep(300); idleAll(); await sup.pipelines.dispatch()
+out = await rpc(qa, "send_back", { task_id: verify().id, to: "code", reason: "Now the 409 body is empty", failures: ["FridDeleteIT.errorBody: expected JSON body"] })
+ok(out.structuredContent.paused && /sent back 2 times \(max 2\)/.test(verify().budget.why), "past max_rounds it stops too")
+res = await api(`/api/tasks/${verify().id}/budget`, { method: "POST", body: { action: "accept" } })
+await sleep(200)
+ok(verify().status === "active" && (await lastText(qa.id)).includes("no more rounds"), "Accept as is tells the checker to finish and list what still fails")
+out = await rpc(qa, "send_back", { task_id: verify().id, to: "plan", reason: "x".repeat(30) })
+ok(!out.isError && out.structuredContent.fix, "any earlier stage can be the target by default")
+idleAll()
+await sup.pipelines.complete(T(r.taskIds.plan), { summary: "Clarified the body." })
+await sleep(300); idleAll()
+out = await rpc(qa, "send_back", { task_id: verify().id, to: "verify", reason: "x".repeat(30) })
+ok(out.isError, "a card cannot send itself back")
+await sup.pipelines.complete(verify(), { summary: "Passes except the empty body.", open_questions: [] })
+await sleep(300)
+ok(sup.pipelines.run(r.id).status === "done" && verify().xp?.reasons.some((x) => x.includes("sent back")), "then it completes, and the checker gets a little for catching things")
+
+console.log("\nfrom the board")
+{
+  const r2 = await sup.pipelines.start({ pipeline: "tdd", workspace: ws.id, story: "US9: board", title: "Board loop" })
+  await sleep(300); idleAll()
+  await sup.pipelines.complete(T(r2.taskIds.plan), { summary: "ok" })
+  await sleep(200); idleAll()
+  await sup.pipelines.complete(T(r2.taskIds.code), { summary: "done" })
+  await sleep(200)
+  ok(T(r2.taskIds.verify).status === "active", "QA is verifying")
+  res = await api(`/api/tasks/${r2.taskIds.code}/send-back`, { method: "POST", body: { reason: "Use the existing ErrorBody class, not a new one" } })
+  await sleep(300)
+  ok(res.status === 200 && T(r2.taskIds.code).round === 2 && T(r2.taskIds.code).rework.by === "operator", "the operator sends a done card back")
+  ok(T(r2.taskIds.verify).status === "blocked" && T(r2.taskIds.verify).recheck, "and the card that was checking it waits for the fix")
+  await sup.pipelines.restart(r2.projectId, { stage: "code", fresh: false })
+  await sleep(200)
+  ok(!T(r2.taskIds.code).round && !T(r2.taskIds.verify).recheck && T(r2.taskIds.verify).dependsOn.length === 1, "restarting forgets the rounds")
+}
+
+console.log("\nsplit stages: the piece that failed, preferring its bot")
+{
+  const r3 = await sup.pipelines.start({ pipeline: "fan", workspace: ws.id, story: "US10: two pieces", title: "Fan loop" })
+  await sleep(300); idleAll()
+  await sup.pipelines.complete(T(r3.taskIds.plan), { summary: "two", tasks: [{ title: "API docs" }, { title: "Service check" }] })
+  await sleep(500); idleAll()
+  const [p1, p2] = T(r3.taskIds.build).children.map(T)
+  const devA = p1.assignee, devB = p2.assignee
+  ok(devA && devB && devA !== devB, "two dev bots build the two pieces")
+  await sup.pipelines.complete(p1, { summary: "docs", artifacts: ["docs/api.md"] })
+  await sup.pipelines.complete(T(p2.id), { summary: "service", artifacts: ["src/main/java/CardService.java"] })
+  await sleep(300); idleAll()
+  const qa3 = sup.store.get(T(r3.taskIds.verify).assignee)
+  sup.store.get(devB).setStatus("busy")
+  out = await rpc(qa3, "send_back", { task_id: r3.taskIds.verify, to: "build", reason: "409 missing", files: ["CardService.java"] })
+  await sleep(300)
+  ok(!out.isError && T(p2.id).status === "queued" && T(p2.id).prefer === devB && T(p1.id).status === "done", "only the piece that touched the file goes back, for the bot that built it")
+  ok(T(r3.taskIds.build).status === "active", "the split card is open again until it lands")
+  await sup.pipelines.dispatch()
+  ok(T(p2.id).status === "queued", "the other dev, though free, leaves it while its own bot has its chance")
+  sup.store.get(devA).setStatus("idle")
+  const waiting = T(p2.id)
+  waiting.preferUntil = Date.now() - 1
+  sup.tasks.save(waiting)
+  await sup.pipelines.dispatch()
+  ok(T(p2.id).status === "active" && T(p2.id).assignee === devA, "after that, a free bot of the same kind takes it")
+  idleAll()
+  await sup.pipelines.complete(T(p2.id), { summary: "fixed" })
+  await sleep(300); idleAll()
+  ok(T(r3.taskIds.build).status === "done" && T(r3.taskIds.verify).status === "active", "the split card lands again and QA verifies")
+  out = await rpc(qa3, "send_back", { task_id: r3.taskIds.verify, to: "build", reason: "The audit log line is missing for deletes" })
+  await sleep(300)
+  const fix = T(r3.taskIds.build).children.map(T).at(-1)
+  ok(!out.isError && fix.title.startsWith("Fix:") && fix.item.index === 3 && fix.owner === "role", "a failure no piece owns becomes a new fix piece for any dev")
+}
+
+sup.stop()
+mock.kill()
+console.log(failed ? `\n${failed} CHECKS FAILED` : "\nall checks passed")
+process.exit(failed ? 1 : 0)