@dirwin517/bot-farm 0.1.0

package/test/mock-opencode.mjs

@@ -0,0 +1,217 @@
+// Minimal fake opencode v2 server: enough of /api to exercise botfarm locally.
+import { createServer } from "node:http"
+
+const sessions = new Map()
+const messages = new Map()
+const listeners = new Set()
+const registered = [] // runtime MCP registrations, for tests
+const created = [] // session create bodies, for tests
+const prompts = [] // instance-engine prompt bodies, for tests
+const pendingP = [], pendingQ = [], replies = []
+const mcpState = new Map()
+const mcpConnects = []
+let mcpDown = false, mcpMode = false // the /mcp map routes switch on with /__mcp-down
+let n = 0
+
+function mkSession({ title, directory }) {
+  const id = "ses_" + (++n).toString().padStart(4, "0")
+  const s = { id, title, directory, time: { created: Date.now(), updated: Date.now() }, agent: "build", model: { providerID: "anthropic", modelID: "claude-opus-5" } }
+  sessions.set(id, s)
+  messages.set(id, [])
+  return s
+}
+const emit = (payload) => {
+  const frame = `data: ${JSON.stringify({ directory: "global", payload })}\n\n`
+  for (const r of listeners) r.write(frame)
+}
+
+// seed two sessions, one of which works continuously
+const a = mkSession({ title: "fix auth redirect", directory: "/home/claude/worktrees/app/fix-auth" })
+const b = mkSession({ title: "flaky test triage", directory: "/home/claude/botfarm" })
+const busy = new Set([a.id])
+
+let step = 0
+setInterval(() => {
+  step++
+  for (const id of busy) {
+    const msgs = messages.get(id)
+    const mid = "msg_" + id + "_" + Math.floor(step / 3)
+    let m = msgs.find((x) => x.id === mid)
+    if (!m) {
+      m = { id, role: "assistant", id: mid, sessionID: id, time: { created: Date.now() }, tokens: { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }, parts: [] }
+      msgs.unshift(m)
+    }
+    m.tokens.output += 150 + Math.floor(Math.random() * 400)
+    m.tokens.input = 12000 + step * 40
+    m.tokens.cache.read = 30000
+    if (step % 2 === 0) {
+      const pid = "prt_" + step
+      m.parts.push({
+        id: pid, type: "tool", name: ["bash", "read", "edit", "grep"][step % 4],
+        state: { status: "completed", input: { command: "npm test -- --watch=false" }, time: { start: Date.now() - 1200, end: Date.now() } },
+      })
+    }
+    m.parts.push({ type: "text", text: "Working on the redirect handler, step " + step })
+    emit({ type: "message.part.updated", properties: { sessionID: id } })
+  }
+}, 500)
+
+createServer(async (req, res) => {
+  const url = new URL(req.url, "http://x")
+  const p = url.pathname
+  const json = (o, code = 200) => { res.writeHead(code, { "content-type": "application/json" }); res.end(JSON.stringify(o)) }
+
+  if (p === "/api/info") return json({ version: "mock", hostname: "127.0.0.1" })
+  if (p === "/api/event") {
+    res.writeHead(200, { "content-type": "text/event-stream" })
+    res.write(`data: ${JSON.stringify({ payload: { type: "server.connected" } })}\n\n`)
+    listeners.add(res)
+    req.on("close", () => listeners.delete(res))
+    return
+  }
+  if (p === "/api/mcp") return json({ data: [{ name: "botfarm", status: "connected", tools: [{ name: "send" }, { name: "roster" }] }, { name: "playwright", status: "disconnected" }] })
+  if (p === "/api/experimental/tool/ids") return json({ data: ["bash", "edit", "read", "grep", "webfetch"] })
+  if (/^\/api\/experimental\/mcp\/[^/]+\/(connect|disconnect)$/.test(p)) return json({ ok: true })
+  if (/^\/api\/experimental\/mcp\/[^/]+$/.test(p) && req.method === "PUT") {
+    const body = JSON.parse(await text(req))
+    registered.push({ name: p.split("/").pop(), directory: url.searchParams.get("location[directory]") ?? url.searchParams.get("directory"), config: body.config })
+    return json({ ok: true })
+  }
+  // --- the instance engine (/session…?directory=), as the TUI uses it ------
+  if (p === "/global/event") {
+    res.writeHead(200, { "content-type": "text/event-stream" })
+    res.write(`data: ${JSON.stringify({ payload: { type: "server.connected" } })}\n\n`)
+    listeners.add(res)
+    req.on("close", () => listeners.delete(res))
+    return
+  }
+  if (p === "/session" && req.method === "POST") {
+    const body = JSON.parse(await text(req))
+    created.push({ ...body, engine: "v1", location: { directory: url.searchParams.get("directory") } })
+    const s = mkSession({ title: body.title, directory: url.searchParams.get("directory") })
+    return json(s)
+  }
+  if (p === "/session/status") {
+    return json(Object.fromEntries([...sessions.keys()].map((id) => [id, { type: busy.has(id) ? "busy" : "idle" }])))
+  }
+  const v1 = /^\/session\/([^/]+)\/(prompt_async|message|abort)$/.exec(p)
+  if (v1 && sessions.has(v1[1])) {
+    const id = v1[1]
+    if (v1[2] === "message") return json((messages.get(id) ?? []).slice(0, Number(url.searchParams.get("limit") ?? 50)).slice().reverse().map((m) => ({ info: m, parts: m.parts })))
+    if (v1[2] === "abort") { busy.delete(id); return json(true) }
+    const body = JSON.parse(await text(req))
+    prompts.push({ id, ...body })
+    messages.get(id).unshift({ id: "msg_in_" + Math.random().toString(36).slice(2, 7), sessionID: id, role: "user", time: { created: Date.now() }, parts: body.parts })
+    busy.add(id)
+    res.writeHead(204)
+    return res.end()
+  }
+  if (p === "/__prompts") return json(prompts)
+  if (p === "/config/providers") {
+    return json({ providers: [{ id: "amazon-bedrock", name: "Amazon Bedrock", models: {
+      "anthropic.claude-sonnet-5": { name: "Claude Sonnet 5", variants: { low: {}, medium: {}, high: {} } },
+      "anthropic.claude-opus-5": { name: "Claude Opus 5", variants: { low: {}, medium: {}, high: {}, max: {} } },
+    } }], default: {} })
+  }
+  // Pending asks from the instance engine, and a way for tests to raise one.
+  if (p === "/__ask" && req.method === "POST") {
+    const body = JSON.parse(await text(req))
+    const id = (body.kind === "question" ? "que_" : "per_") + Math.random().toString(36).slice(2, 8)
+    ;(body.kind === "question" ? pendingQ : pendingP).push({ id, ...body.request, sessionID: body.sessionID })
+    emit({ type: body.kind === "question" ? "question.asked" : "permission.asked", properties: { sessionID: body.sessionID, id } })
+    return json({ id })
+  }
+  if (p === "/permission") return json(pendingP)
+  if (p === "/question") return json(pendingQ)
+  const rep = /^\/(permission|question)\/([^/]+)\/(reply|reject)$/.exec(p)
+  if (rep) {
+    const body = JSON.parse((await text(req)) || "{}")
+    replies.push({ kind: rep[1], id: rep[2], action: rep[3], ...body })
+    const list = rep[1] === "permission" ? pendingP : pendingQ
+    const i = list.findIndex((x) => x.id === rep[2])
+    if (i >= 0) list.splice(i, 1)
+    return json(true)
+  }
+  // MCP status per directory. "local-dev" starts failed, as when the docker
+  // server was down when opencode opened the directory; /connect fixes it
+  // unless /__mcp-down says the server is still down.
+  if (p === "/mcp" && req.method === "GET" && mcpMode) {
+    const dir = url.searchParams.get("directory")
+    return json({ botfarm: { status: "connected" }, "local-dev": mcpState.get(dir) ?? { status: "failed", error: "server unavailable" }, rag: { status: "disabled" } })
+  }
+  const conn = /^\/mcp\/([^/]+)\/connect$/.exec(p)
+  if (conn && req.method === "POST" && mcpMode) {
+    mcpConnects.push({ name: decodeURIComponent(conn[1]), directory: url.searchParams.get("directory") })
+    if (!mcpDown) mcpState.set(url.searchParams.get("directory"), { status: "connected" })
+    return json(true)
+  }
+  if (p === "/__mcp-down") { mcpMode = true; mcpDown = url.searchParams.get("down") === "1"; if (mcpDown) mcpState.clear(); return json(mcpDown) }
+  if (p === "/__mcp-connects") return json(mcpConnects)
+  if (p === "/__replies") return json(replies)
+  if (p === "/__registered") return json(registered)
+  if (p === "/config" && req.method === "GET") {
+    // What a real server resolves for a directory: its opencode.json files, merged.
+    const { readFileSync } = await import("node:fs")
+    const dir = url.searchParams.get("directory")
+    const out = { agent: {}, mcp: {} }
+    for (const f of ["opencode.json", ".opencode/opencode.json"]) {
+      try {
+        const c = JSON.parse(readFileSync(dir + "/" + f, "utf8").replace(/^\s*\/\/.*$/gm, "").replace(/,(\s*[}\]])/g, "$1"))
+        Object.assign(out.agent, c.agent ?? {}); Object.assign(out.mcp, c.mcp ?? {}); if (c.model) out.model = c.model
+      } catch {}
+    }
+    return json(out)
+  }
+  if (p === "/__created") return json(created)
+  // Oldest first and capped, like a real server with a long history: the
+  // newest sessions are the ones that fall off a single page.
+  if (p === "/api/session" && req.method === "GET") return json({ data: [...sessions.values()].slice(0, Number(url.searchParams.get("limit") ?? 1000)) })
+  if (p === "/api/session" && req.method === "POST") {
+    const body = JSON.parse(await text(req))
+    created.push(body)
+    const s = mkSession({ title: body.title, directory: body.location?.directory })
+    emit({ type: "session.created", properties: { info: s } })
+    return json({ data: s })
+  }
+  if (p === "/api/session/active") return json({ data: Object.fromEntries([...busy].map((id) => [id, true])) })
+  const m = /^\/api\/session\/([^/]+)(\/.*)?$/.exec(p)
+  if (m) {
+    const id = m[1]
+    const tail = m[2] ?? ""
+    if (!sessions.has(id)) return json({ error: "not found" }, 404)
+    if (tail === "/message") return json({ data: (messages.get(id) ?? []).slice(0, Number(url.searchParams.get("limit") ?? 20)) })
+    if (tail === "/prompt" || tail === "/synthetic") {
+      const body = JSON.parse(await text(req))
+      if (tail === "/prompt" && !body.prompt) {
+        res.writeHead(400, { "content-type": "application/json" })
+        return res.end(JSON.stringify({ _tag: "InvalidRequestError", message: 'Missing key\n at ["prompt"]', kind: "Payload" }))
+      }
+      const promptText = body.prompt?.text ?? body.message?.text ?? body.prompt ?? body.text ?? ""
+      if (!promptText) {
+        res.writeHead(400, { "content-type": "application/json" })
+        return res.end(JSON.stringify({ _tag: "InvalidRequestError", message: "no text in payload", kind: "Payload" }))
+      }
+      messages.get(id).unshift({
+        id: "msg_in_" + Math.random().toString(36).slice(2, 7), sessionID: id,
+        role: tail === "/synthetic" ? "synthetic" : "user",
+        time: { created: Date.now() },
+        parts: [{ type: "text", text: promptText }],
+      })
+      busy.add(id)
+      emit({ type: "message.updated", properties: { sessionID: id } })
+      return json({ data: { id: "msg_x" } })
+    }
+    if (tail === "/interrupt") { busy.delete(id); return json({ interrupted: true }) }
+    if (tail === "/permission") return json({ data: [] })
+    if (tail === "/compact") { res.writeHead(204); return res.end() }
+    if (!tail && req.method === "DELETE") { sessions.delete(id); busy.delete(id); res.writeHead(204); return res.end() }
+    if (!tail) return json({ data: sessions.get(id) })
+  }
+  json({ error: "no route " + p }, 404)
+}).listen(4096, () => console.log("mock opencode on http://127.0.0.1:4096"))
+
+async function text(req) {
+  const c = []
+  for await (const x of req) c.push(x)
+  return Buffer.concat(c).toString()
+}

package/test/parallel.mjs

@@ -0,0 +1,135 @@
+// Fan-out and join: a stage split into one card per item of an earlier
+// handoff, worked by several bots of one kind at once; "after:" for stages
+// that run side by side (TDD); time/token/$ limits that stop and ask.
+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(), "par-"))
+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(), "parh-"))
+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:4839" })
+await sup.start()
+startServer({ supervisor: sup, port: 4839 })
+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 idleAll = () => { for (const s of sup.store.list()) s.setStatus("idle") }
+const T = (id) => sup.tasks.get(id)
+
+sup.pipelines.definitions.set("fan", {
+  id: "fan",
+  title: "Plan, build in parallel, test alongside",
+  stages: [
+    { id: "plan", persona: "product", title: "Plan the pieces", receives: [], prompt: "{{story}}" },
+    { id: "build", persona: "dev", title: "Build", receives: ["plan"], split: "tasks", parallel: 3, limits: { minutes: 30 }, prompt: "Build it." },
+    { id: "tests", persona: "qa", title: "Write the tests first", receives: ["plan"], after: ["plan"], prompt: "Write failing tests for the criteria." },
+    { id: "check", persona: "reviewer", title: "Check", receives: ["build", "tests"], after: ["build", "tests"], prompt: "{{#handoffs.build}}{{summary}}{{/handoffs.build}}" },
+  ],
+})
+
+console.log("a stage that waits on an earlier one, not the one before it")
+const r = await sup.pipelines.start({ pipeline: "fan", repo, branch: "feat/fan", story: "US9: ten little changes", title: "Fan", limits: { minutes: 600 } })
+await sleep(300)
+ok(T(r.taskIds.plan).status === "active" && T(r.taskIds.build).status === "blocked" && T(r.taskIds.tests).status === "blocked", "only the first stage starts")
+const plan = (await texts(r.sessions.product)).find((t) => t.includes("[botfarm] task"))
+ok(plan?.includes("tasks") && plan.includes("REQUIRED") && plan.includes("dev bot"), "the stage feeding a split is asked for a task list")
+idleAll()
+await sup.pipelines.complete(T(r.taskIds.plan), { summary: "Four pieces.", acceptance_criteria: ["all four"], tasks: ["Add the DAO method", { title: "Add the endpoint", detail: "DELETE /things/{id} returns 409 when a FRID exists" }, "Wire the service", "Update the docs"] })
+await sleep(400)
+const build = T(r.taskIds.build)
+ok(T(r.taskIds.tests).status === "active", "QA starts on the tests at the same time as the devs (after: [plan])")
+ok(build.children?.length === 4 && build.status === "active", "the build card fans out into one card per item")
+const kids = build.children.map(T)
+ok(kids[1].title === "Add the endpoint" && kids[1].item.detail.includes("409") && kids[1].item.total === 4, "each with its own title and detail")
+const devs = sup.projects.sessions(r.projectId).filter((s) => s.persona === "dev")
+ok(devs.length === 3, `up to three dev bots work it (${devs.length})`)
+ok(kids.filter((k) => k.status === "active").length === 3 && kids.filter((k) => k.status === "queued").length === 1, "three pieces at once, the fourth waits its turn")
+ok(new Set(kids.filter((k) => k.assignee).map((k) => k.assignee)).size === 3, "each on a different bot")
+const kidPrompt = (await texts(kids[0].assignee)).find((t) => t.includes(kids[0].id))
+ok(kidPrompt?.includes("Your part — 1 of 4: Add the DAO method") && kidPrompt.includes("Do only your piece"), "a piece knows which part it is and that others share the worktree")
+ok(kidPrompt?.includes("You are @"), "a new dev bot gets the dev brief with its first piece")
+ok(sup.pipelines.run(r.id).sessions["dev-2"] && sup.rooms.rooms.get(r.roomId ?? sup.pipelines.run(r.id).roomId).members.size >= 6, "the extra bots join the team and the chat")
+
+console.log("\nthe stage after waits for every piece")
+const first = kids.find((k) => k.status === "active")
+idleAll()
+await sup.pipelines.complete(T(first.id), { summary: "DAO method added.", artifacts: ["Dao.java"] })
+await sleep(300)
+ok(T(kids.find((k) => k.status === "queued").id).status === "active", "a finished bot picks up the waiting piece")
+ok(T(r.taskIds.build).status === "active" && T(r.taskIds.check).status === "blocked", "the build card is still open")
+for (const k of kids.map((k) => T(k.id)).filter((k) => k.status === "active")) {
+  idleAll()
+  await sup.pipelines.complete(k, { summary: `Did ${k.title}.`, artifacts: [`${k.item.index}.java`], open_questions: k.item.index === 4 ? ["Which doc site?"] : [] })
+}
+await sleep(300)
+const joined = T(r.taskIds.build)
+ok(joined.status === "done" && joined.handoff.parts.length === 4, "when the last piece lands, the card is done")
+ok(joined.handoff.summary.includes("DAO method added.") && joined.handoff.summary.includes("[2/4] Add the endpoint") && joined.handoff.artifacts.length === 4, "with every piece's handoff joined")
+ok(joined.handoff.open_questions.includes("Which doc site?"), "open questions from a piece travel on")
+ok(T(r.taskIds.check).status === "blocked", "the reviewer still waits for QA")
+idleAll()
+await sup.pipelines.complete(T(r.taskIds.tests), { summary: "Tests written, failing as expected." })
+await sleep(300)
+ok(T(r.taskIds.check).status === "active", "and starts once both are in")
+const check = (await texts(r.sessions.reviewer)).find((t) => t.includes("[botfarm] task"))
+ok(check?.includes("DAO method added.") && check.includes("Did Update the docs."), "reading the joined handoff")
+
+console.log("\na card over its limit stops and asks")
+const r2 = await sup.pipelines.start({ pipeline: "fan", repo, branch: "feat/fan2", story: "US10: two", title: "Fan2" })
+await sleep(300)
+idleAll()
+await sup.pipelines.complete(T(r2.taskIds.plan), { summary: "Two.", tasks: ["one", "two"] })
+await sleep(300)
+const piece = T(T(r2.taskIds.build).children[0])
+ok(sup.projects.sessions(r2.projectId).filter((s) => s.persona === "dev").length === 2, "two pieces bring two dev bots, not three")
+ok(!sup.tasks.all({ projectId: r.projectId }).some((t) => t.parentId === r2.taskIds.build), "(and this workstream's pieces stay here)")
+await sup.pipelines.checkBudgets(Date.now() + 40 * 60_000) // past 30 min even with a Seasoned +10%
+let p2 = T(piece.id)
+ok(p2.status === "review" && p2.budget?.kind === "minutes", "past its 30 minutes it is stopped and waits for you")
+ok(sup.store.events.some((e) => /reached its time/.test(e.text)), "with a note saying why")
+let res = await fetch(`http://127.0.0.1:4839/api/tasks/${piece.id}/budget`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ action: "continue" }) })
+p2 = T(piece.id)
+ok(res.ok && p2.status === "active" && p2.limits.minutes > 31 && !p2.budget, "Continue gives it half as much again and wakes the bot")
+ok((await texts(p2.assignee)).some((t) => t.includes("gave you more room")), "which is told to carry on")
+
+console.log("\na workstream over its limit stops every bot")
+await fetch(`http://127.0.0.1:4839/api/projects/${r2.projectId}/budget`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ limits: { tokens: 1 } }) })
+sup.store.get(r2.sessions.dev).totals.output += 50
+await sup.pipelines.checkBudgets()
+const run2 = sup.pipelines.run(r2.id)
+ok(run2.paused?.kind === "tokens", "past its token limit the workstream pauses")
+const snap = JSON.parse(JSON.stringify(sup.snapshot?.() ?? {}))
+res = await fetch(`http://127.0.0.1:4839/api/projects/${r2.projectId}/budget`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ action: "continue", limits: { tokens: 10 } }) })
+ok(!res.ok && sup.pipelines.run(r2.id).paused, "it will not resume into a limit it is still over")
+res = await fetch(`http://127.0.0.1:4839/api/projects/${r2.projectId}/budget`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ action: "continue", limits: { tokens: 1_000_000, usd: 20 } }) })
+ok(res.ok && !sup.pipelines.run(r2.id).paused && sup.pipelines.run(r2.id).limits.usd === 20, "raising it resumes the workstream")
+res = await fetch(`http://127.0.0.1:4839/api/tasks/${T(r2.taskIds.build).children[1]}/budget`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ limits: { usd: 2 } }) })
+ok(res.ok && T(T(r2.taskIds.build).children[1]).limits.usd === 2, "a card's limits can be set by hand")
+
+console.log("\nrestarting puts a split card back together")
+await sup.pipelines.restart(r.projectId, { stage: "build", fresh: false })
+await sleep(300)
+const again = T(r.taskIds.build)
+ok(again.children?.length === 4 && again.children.every((id) => !kids.some((k) => k.id === id)), "and fans it out again from the handoff")
+
+console.log("\npipelines check the new fields")
+const { checkPipelineDoc } = await import("../src/pipelines.mjs")
+const probs = checkPipelineDoc({ stages: [{ id: "a", persona: "dev" }, { id: "b", persona: "dev", after: ["zz"], parallel: 40, limits: { usd: -1 } }] }, new Map([["dev", {}]]))
+ok(probs.some((p) => p.includes('after "zz"')) && probs.some((p) => p.includes("parallel")) && probs.some((p) => p.includes("limits")), "bad after / parallel / limits are reported")
+
+sup.stop()
+mock.kill()
+console.log(failed ? `\n${failed} CHECKS FAILED` : "\nall checks passed")
+process.exit(failed ? 1 : 0)

package/test/patches.mjs

@@ -0,0 +1,93 @@
+// The work as patches, applied to the real checkouts.
+import { spawn as spawnProc, execFile } from "node:child_process"
+import { promisify } from "node:util"
+import { mkdtemp, writeFile, readFile, 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"
+
+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 G = (cwd, ...args) => run("git", args, { cwd }).then((r) => r.stdout)
+const commit = async (dir, msg = "i") => { await G(dir, "add", "-A"); await G(dir, "-c", "user.email=t@t", "-c", "user.name=t", "commit", "-qm", msg) }
+const mkrepo = async (dir, files) => {
+  await mkdir(dir, { recursive: true })
+  await G(dir, "init", "-q", "-b", "main")
+  for (const [f, t] of Object.entries(files)) { await mkdir(join(dir, f, ".."), { recursive: true }); await writeFile(join(dir, f), t) }
+  await commit(dir)
+  return dir
+}
+const base = await mkdtemp(join(tmpdir(), "patch-"))
+const repo = await mkrepo(join(base, "java-parent-services"), { "pom.xml": "<project/>\n", ".gitignore": "src/\n", "Readme.md": "one\ntwo\nthree\n" })
+const svc = await mkrepo(join(repo, "src", "card-service"), { "Card.java": "class Card {\n  int a = 1;\n}\n" })
+const spt = await mkrepo(join(base, "elsewhere", "spt"), { "App.java": "class App {}\n" })
+const home = await mkdtemp(join(tmpdir(), "patchh-"))
+process.env.BOT_FARM_WORKTREE_ROOT = join(home, "wt")
+await sleep(600)
+const PORT = 4851
+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 ws = await sup.workspaces.add({ path: repo, name: "jps" })
+await sup.workspaces.addLinked(ws.id, { path: spt })
+const r = await sup.pipelines.start({ pipeline: "story", workspace: ws.id, story: "US1", title: "Patches", services: ["src/card-service", spt] })
+await sleep(400)
+const wt = sup.projects.get(r.projectId).worktree
+
+// The "bots'" work: an edit, a new file, a commit on the branch, work in a service and a linked repo.
+await writeFile(join(wt, "Readme.md"), "one\ntwo changed\nthree\n")
+await writeFile(join(wt, "New.java"), "class New {}\n")
+await writeFile(join(wt, "src", "card-service", "Card.java"), "class Card {\n  int a = 2;\n}\n")
+await writeFile(join(wt, "spt", "Extra.java"), "class Extra {}\n")
+await writeFile(join(wt, "spt", "App.java"), "class App { int x; }\n")
+await commit(join(wt, "spt"), "bot committed this one")
+
+console.log("what would go where")
+let res = await api(`/api/projects/${r.projectId}/patches`)
+const byRel = Object.fromEntries(res.body.repos.map((x) => [x.rel, x]))
+ok(res.status === 200 && res.body.repos.length === 3, "one patch per repo: the parent, the service and the linked repo")
+ok(byRel[""].files.map((f) => f.path).sort().join() === "New.java,Readme.md", "the parent's patch has the edit and the new file — none of BotFarm's own files")
+ok(byRel["src/card-service"].files.length === 1 && byRel["spt"].files.length === 2 && byRel["spt"].commits === 1, "committed work on the branch counts too")
+ok(res.body.repos.every((x) => x.check?.how === "clean"), "and every one would apply cleanly")
+ok((await G(wt, "status", "--porcelain")).includes("?? New.java"), "the worktree's own index is left alone")
+const dl = await fetch(`http://127.0.0.1:${PORT}/api/projects/${r.projectId}/patches/file?rel=src%2Fcard-service`)
+ok(dl.status === 200 && (await dl.text()).includes("+  int a = 2;"), "each patch can be downloaded")
+
+console.log("\napplying")
+res = await api(`/api/projects/${r.projectId}/patches/apply`, { method: "POST", body: {} })
+ok(res.status === 200 && res.body.results.filter((x) => x.how === "clean").length === 3, "all three go in cleanly")
+ok((await readFile(join(repo, "Readme.md"), "utf8")).includes("two changed") && await stat(join(repo, "New.java")).then(() => true, () => false), "the real checkout has the edit and the new file")
+ok((await readFile(join(svc, "Card.java"), "utf8")).includes("a = 2") && (await readFile(join(spt, "App.java"), "utf8")).includes("int x"), "and so do the service and the linked repo")
+ok((await G(repo, "log", "--oneline")).trim().split("\n").length === 1 && (await G(spt, "log", "--oneline")).trim().split("\n").length === 1, "nothing is committed for you")
+ok((await G(repo, "diff", "--cached", "--name-only")).trim() === "", "and nothing is staged: review and commit as you like")
+ok(sup.projects.room(r.projectId, { create: false })?.messages.some((m) => m.text.includes("Applied the work")), "the chat says what happened")
+ok((await api(`/api/projects/${r.projectId}/patches`)).body.repos.every((x) => x.check?.how === "present"), "afterwards the preview says it is already in your repos")
+
+console.log("\nundo")
+res = await api(`/api/projects/${r.projectId}/patches/undo`, { method: "POST", body: {} })
+ok(res.status === 200 && res.body.every((x) => x.undone), "Undo takes the clean ones back out")
+ok(!(await readFile(join(repo, "Readme.md"), "utf8")).includes("changed") && (await G(spt, "status", "--porcelain")).trim() === "", "and the real repos are as they were")
+
+console.log("\nwhen the real repo moved on")
+await writeFile(join(repo, "Readme.md"), "one\ntwo mine\nthree\n")
+await commit(repo, "you changed the same line")
+res = await api(`/api/projects/${r.projectId}/patches`)
+ok(res.body.repos.find((x) => x.rel === "").check.how !== "clean", "the preview says the parent will not apply cleanly")
+res = await api(`/api/projects/${r.projectId}/patches/apply`, { method: "POST", body: { repos: [""] } })
+const parent = res.body.results[0]
+ok(res.body.results.length === 1 && ["conflicts", "3way", "partial"].includes(parent.how), `it is applied as far as it goes (${parent.how})`)
+ok(parent.how !== "conflicts" || (await readFile(join(repo, "Readme.md"), "utf8")).includes("<<<<<<<"), "with conflict markers to resolve, like a merge")
+ok(await stat(join(repo, "New.java")).then(() => true, () => false), "the parts that fit are in")
+
+sup.stop()
+mock.kill()
+console.log(failed ? `\n${failed} CHECKS FAILED` : "\nall checks passed")
+process.exit(failed ? 1 : 0)

package/test/repos.mjs

@@ -0,0 +1,118 @@
+// Paths people actually type, and a parent repo with services cloned into a
+// gitignored folder — the layout that broke "start a pipeline".
+import { execFile } from "node:child_process"
+import { promisify } from "node:util"
+import { mkdtemp, writeFile, mkdir, readdir } from "node:fs/promises"
+import { tmpdir, homedir } from "node:os"
+import { join } from "node:path"
+import * as git from "../src/git.mjs"
+
+const run = promisify(execFile)
+let failed = 0
+const ok = (c, m) => (c ? console.log("  ok  " + m) : (failed++, console.error("  FAIL " + m)))
+
+const commit = async (dir, msg = "init") => {
+  await run("git", ["add", "-A"], { cwd: dir })
+  await run("git", ["-c", "user.email=t@t", "-c", "user.name=t", "commit", "-qm", msg], { cwd: dir })
+}
+const init = async (dir) => {
+  await mkdir(dir, { recursive: true })
+  await run("git", ["init", "-q", "-b", "main"], { cwd: dir })
+}
+
+console.log("paths as typed")
+ok(git.expandPath("~") === homedir(), "a bare tilde expands to $HOME")
+ok(git.expandPath("~/workspace/x") === join(homedir(), "workspace/x"), "and so does ~/workspace/x")
+ok(git.expandPath("  ~/a/b/  ") === join(homedir(), "a/b"), "surrounding whitespace is ignored")
+ok(git.expandPath("$HOME/x") === join(homedir(), "x"), "environment variables expand")
+ok(git.expandPath("/tmp/abs") === "/tmp/abs", "absolute paths are left alone")
+
+console.log("\nsaying what is actually wrong")
+let info = await git.inspect("~/definitely-not-here-" + Math.random().toString(36).slice(2))
+ok(!info.exists && /no such directory/.test(info.reason), `a missing path says so ("${info.reason}")`)
+const plain = await mkdtemp(join(tmpdir(), "plain-"))
+info = await git.inspect(plain)
+ok(info.exists && !info.isRepo && /not a git repository/.test(info.reason), "a real directory that is not a repo says that instead")
+
+console.log("\na parent repo with services in a gitignored folder")
+const parent = await mkdtemp(join(tmpdir(), "java-parent-services-"))
+await init(parent)
+await writeFile(join(parent, "pom.xml"), "<project/>\n")
+await writeFile(join(parent, ".gitignore"), "src/\n")
+await commit(parent)
+const services = ["billing", "identity", "notifications"]
+for (const name of services) {
+  const dir = join(parent, "src", name)
+  await init(dir)
+  await writeFile(join(dir, "README.md"), `# ${name}\n`)
+  await commit(dir)
+}
+
+info = await git.inspect(parent)
+ok(info.isRepo, "the parent is recognised as a repository")
+ok(info.nested.length === 3, `its ${info.nested.length} nested repos are found even though git ignores them`)
+ok(info.nested.every((n) => n.rel.startsWith("src/")), "reported by path relative to the parent")
+ok(info.nested[0].branch === "main", "with the branch each one is on")
+
+console.log("\none worktree per repo, same layout")
+const set = await git.addWorktreeSet(parent, "feat/sso", {
+  path: join(tmpdir(), "wt-" + Date.now()),
+  include: ["src/billing", "src/identity"],
+})
+ok(set.branch === "feat/sso", "the parent gets the branch")
+ok(set.children.length === 2 && set.children.every((c) => !c.error), "so do the selected services")
+const listed = await readdir(join(set.path, "src"))
+ok(listed.includes("billing") && listed.includes("identity"), "laid out where the agent expects them")
+ok(!listed.includes("notifications"), "and services you did not select are left out")
+const billingBranch = (await git.status(join(set.path, "src", "billing")))?.branch
+ok(billingBranch === "feat/sso", "each service worktree is on its own copy of the branch")
+const origin = await git.status(join(parent, "src", "billing"))
+ok(origin.branch === "main", "while the original checkout stays where it was")
+
+console.log("\nchanges across all of them")
+await writeFile(join(set.path, "pom.xml"), "<project><module/></project>\n")
+await writeFile(join(set.path, "src", "billing", "Invoice.java"), "class Invoice {}\n")
+await writeFile(join(set.path, "src", "identity", "README.md"), "# identity\nchanged\n")
+const changed = await git.changedFiles(set.path)
+ok(changed.some((f) => f.path === "pom.xml"), "the parent's own change is listed")
+ok(changed.some((f) => f.path === "src/billing/Invoice.java" && f.repo === "src/billing"), "a new file in a service is listed, tagged with its repo")
+ok(changed.some((f) => f.path === "src/identity/README.md" && f.removed >= 0), "as is an edit inside another service")
+
+console.log("\ndiffing a file that belongs to a nested repo")
+const diff = await git.diffFile(set.path, "src/identity/README.md")
+ok(/changed/.test(diff), "the diff is fetched from the repo that owns the file")
+
+console.log("\ncleaning up removes every worktree it made")
+const removed = await git.removeWorktreeSet(set.path, { force: true })
+ok(removed.length === 2, `both service worktrees were removed (${removed.join(", ")})`)
+const left = await git.nestedRepos(parent)
+ok(left.length === 3, "and the original checkouts are untouched")
+
+console.log("\na repo from somewhere else, mounted in the worktree")
+{
+  const ws = await mkdtemp(join(tmpdir(), "jps-"))
+  await init(ws); await writeFile(join(ws, "pom.xml"), "<project/>\n"); await commit(ws)
+  const spt = join(await mkdtemp(join(tmpdir(), "elsewhere-")), "spt")
+  await init(spt); await writeFile(join(spt, "App.java"), "class App {}\n"); await commit(spt)
+  const srcs = git.serviceSources(ws, [spt, { path: spt, as: "spt-two" }, "src/x"])
+  ok(srcs[0].external && srcs[0].rel === "spt" && srcs[1].rel === "spt-two" && !srcs[2].external && srcs[2].source === join(ws, "src/x"), "an absolute path mounts under its folder name (or `as`); a relative one is nested")
+  let threw = await git.checkService(ws, join(tmpdir(), "nope-" + Date.now())).then(() => null, (e) => e.message)
+  ok(/not a git repository/.test(threw ?? ""), "a folder that is not a repo is refused")
+  threw = await git.checkService(ws, spt, { taken: ["spt"] }).then(() => null, (e) => e.message)
+  ok(/already has something at spt/.test(threw ?? ""), "so is a mount name already taken")
+  const wtPath = join(await mkdtemp(join(tmpdir(), "wt-")), "b")
+  const set2 = await git.addWorktreeSet(ws, "botfarm/ext", { path: wtPath, include: [spt] })
+  const child = set2.children[0]
+  ok(!child.error && child.path === join(wtPath, "spt") && child.branch === "botfarm/ext", "it gets a worktree inside the workstream's, on the same branch")
+  const st = await git.status(wtPath)
+  ok(st.untracked === 0, "and the parent's git status does not list it")
+  await writeFile(join(child.path, "New.java"), "class New {}\n")
+  ok((await git.changedFiles(wtPath)).some((f) => f.path === "spt/New.java" && f.repo === "spt"), "changes in it show up with the workstream's")
+  const snap = await git.snapshot(wtPath)
+  ok(Object.keys(snap.repos).includes("spt"), "and in card snapshots")
+  const removed2 = await git.removeWorktreeSet(wtPath, { force: true })
+  ok(removed2.includes("spt") && (await git.listWorktrees(spt)).length === 1, "removing the workstream removes its worktree of the other repo too")
+}
+
+console.log(failed ? `\n${failed} CHECKS FAILED` : "\nall checks passed")
+process.exit(failed ? 1 : 0)