pi-agent-fleet 0.3.0 → 0.4.0

package/src/controller.ts

@@ -166,12 +166,15 @@ export async function startLoop(fleet: ActiveFleet, ctx: ExtensionContext, resum
       const prompt = await readFile(join(fleet.fleetRoot, "workers", nodeId, "prompt.md"), "utf-8");
       const sessionDir = join(fleet.fleetRoot, "workers", nodeId);
       const effort = worker.effort ?? fleet.spec.config.effort ?? "medium";
+      const worktreeCwd = worker?.worktree || worker?.id === "fleet-integrator"
+        ? join(fleet.fleetRoot, "worktrees", nodeId)
+        : ctx.cwd;
       try {
         return await runWorker({
           nodeId,
           worker: workerWithResolvedModel(worker, resolvedModel),
           prompt,
-          repoCwd: ctx.cwd,
+          repoCwd: worktreeCwd,
           sessionDir,
           thinkingLevel: effort,
           sessionFactory: resolvedModel ? sessionFactoryForModel(resolvedModel) : undefined,
@@ -200,9 +203,12 @@ export async function startLoop(fleet: ActiveFleet, ctx: ExtensionContext, resum
     const state = await runFleet({
       spec: fleet.spec,
       fleetRoot: fleet.fleetRoot,
+      baseRepo: ctx.cwd,
       repoCwd: (nodeId) => {
         const worker = fleet.spec.workers.find((w) => w.id === nodeId);
-        return worker?.worktree ? join(fleet.fleetRoot, "worktrees", nodeId) : ctx.cwd;
+        return worker?.worktree || worker?.id === "fleet-integrator"
+          ? join(fleet.fleetRoot, "worktrees", nodeId)
+          : ctx.cwd;
       },
       spawn,
       killSwitch: fleet.killSwitch,

package/src/dag.ts

@@ -49,6 +49,47 @@ export function getDependents(spec: FleetSpec, nodeId: string): string[] {
   return spec.workers.filter((w) => w.depends_on.includes(nodeId)).map((w) => w.id);
 }
 
+function findWorktreeOwnershipConflicts(workers: WorkerSpec[]): string[] {
+  const worktrees = workers.filter((w) => w.worktree);
+  const claims = new Map<string, string[]>();
+  for (const w of worktrees) {
+    for (const o of w.outputs) {
+      if (!o.path.startsWith("output/")) {
+        const list = claims.get(o.path) ?? [];
+        list.push(w.id);
+        claims.set(o.path, list);
+      }
+    }
+  }
+  const errors: string[] = [];
+  const byId = new Map(workers.map((w) => [w.id, w]));
+  for (const [path, ids] of claims) {
+    if (ids.length < 2) continue;
+    for (let i = 0; i < ids.length; i++) {
+      for (let j = i + 1; j < ids.length; j++) {
+        const a = ids[i], b = ids[j];
+        const aBeforeB = byId.get(a)!.depends_on.includes(b);
+        const bBeforeA = byId.get(b)!.depends_on.includes(a);
+        if (!aBeforeB && !bBeforeA) {
+          errors.push(`worktree ownership conflict: "${path}" claimed by "${a}" and "${b}" without ordered handoff`);
+        }
+      }
+    }
+  }
+  return errors;
+}
+
+function hasIntegratorPath(workers: WorkerSpec[]): boolean {
+  const worktreeIds = new Set(workers.filter((w) => w.worktree).map((w) => w.id));
+  if (worktreeIds.size < 2) return true;
+  return workers.some((w) => {
+    if (w.worktree) return false;
+    const deps = new Set(w.depends_on);
+    for (const id of worktreeIds) if (!deps.has(id)) return false;
+    return true;
+  });
+}
+
 export function validateFleetSpec(
   raw: unknown,
 ): { ok: true; spec: FleetSpec; layers: string[][] } | { ok: false; errors: string[] } {
@@ -115,6 +156,23 @@ export function validateFleetSpec(
     }
   }
 
+  const worktreeIds = new Set(workers.filter((w) => w.worktree).map((w) => w.id));
+  if (worktreeIds.size >= 2) {
+    if (!workers.some((w) => w.id === "fleet-integrator")) {
+      workers.push({
+        id: "fleet-integrator",
+        type: "code-run",
+        task: `Merge worktree branches in order: ${[...worktreeIds].join(", ")}. Verify the combined repo is consistent and commit if needed.`,
+        depends_on: [...worktreeIds],
+        outputs: [],
+      });
+    }
+    if (!hasIntegratorPath(workers)) {
+      errors.push("multiple worktree workers require an integrator that depends on all worktree workers");
+    }
+    errors.push(...findWorktreeOwnershipConflicts(workers));
+  }
+
   let loopConfig: LoopConfig | undefined;
   if (cfg.loop !== undefined && cfg.loop !== null) {
     if (typeof cfg.loop !== "object" || Array.isArray(cfg.loop)) {

package/src/scheduler.ts

@@ -4,12 +4,14 @@ import { verifyOutputs } from "./contracts.js";
 import { archiveIteration, initFleetState, patchNode, resetForIteration, snapshotIteration, writeState } from "./state.js";
 import { TERMINAL_NODE_STATUSES } from "./types.js";
 import type { FleetSpec, FleetState, IterationSnapshot, NodeState, Verdict, WorkerSpec } from "./types.js";
+import { commitWorktree, createWorktree, prepareIntegratorWorktree } from "./worktree.js";
 
 export type SpawnFn = (nodeId: string) => Promise<{ ok: boolean; turns: number; tokens: number; cost?: number; error?: string }>;
 
 export interface RunFleetOpts {
   spec: FleetSpec;
   fleetRoot: string;
+  baseRepo?: string;
   repoCwd: string | ((nodeId: string) => string);
   spawn: SpawnFn;
   onNodeChange?: (nodeId: string, s: NodeState) => void;
@@ -72,6 +74,41 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
   const repoCwdFor = (nodeId: string): string =>
     typeof opts.repoCwd === "function" ? opts.repoCwd(nodeId) : opts.repoCwd;
 
+  const baseRepo = (): string | undefined =>
+    opts.baseRepo ?? (typeof opts.repoCwd === "string" ? opts.repoCwd : undefined);
+
+  function orderedWorktreeBranches(spec: FleetSpec): string[] {
+    const ids = spec.workers.filter((w) => w.worktree).map((w) => w.id);
+    const set = new Set(ids);
+    const indeg = new Map(ids.map((id) => [id, 0]));
+    const rev = new Map(ids.map((id) => [id, [] as string[]]));
+    for (const w of spec.workers) {
+      if (!set.has(w.id)) continue;
+      for (const d of w.depends_on) {
+        if (set.has(d)) {
+          indeg.set(w.id, (indeg.get(w.id) ?? 0) + 1);
+          rev.get(d)?.push(w.id);
+        }
+      }
+    }
+    const sorted: string[] = [];
+    let current = ids.filter((id) => indeg.get(id) === 0);
+    while (current.length > 0) {
+      sorted.push(...current);
+      const next: string[] = [];
+      for (const id of current) {
+        for (const m of rev.get(id) ?? []) {
+          const v = (indeg.get(m) ?? 0) - 1;
+          indeg.set(m, v);
+          if (v === 0) next.push(m);
+        }
+      }
+      current = next;
+    }
+    if (sorted.length !== ids.length) sorted.push(...ids.filter((id) => !sorted.includes(id)));
+    return sorted.map((id) => `fleet/${spec.fleet_name}/${id}`);
+  }
+
   const runPass = async (): Promise<void> => {
     while (true) {
       // auto-initialize workers inserted into the spec after the run started
@@ -122,6 +159,61 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
         const depsDone = w.depends_on.every((d) => state.nodes[d]?.status === "completed");
         if (!depsDone) continue;
         slots--;
+
+        if (w.worktree) {
+          const repo = baseRepo();
+          if (!repo) {
+            await patch(w.id, {
+              status: "failed",
+              ended_at: new Date().toISOString(),
+              status_note: "worktree worker requires a baseRepo",
+            });
+            continue;
+          }
+          try {
+            await createWorktree({
+              baseRepo: repo,
+              fleetName: spec.fleet_name,
+              nodeId: w.id,
+              fleetRoot,
+            });
+          } catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            await patch(w.id, {
+              status: "failed",
+              ended_at: new Date().toISOString(),
+              status_note: `worktree creation failed: ${msg}`,
+            });
+            continue;
+          }
+        }
+
+        if (w.id === "fleet-integrator") {
+          const repo = baseRepo();
+          if (!repo) {
+            await patch(w.id, {
+              status: "failed",
+              ended_at: new Date().toISOString(),
+              status_note: "integrator requires a baseRepo",
+            });
+            continue;
+          }
+          const prep = await prepareIntegratorWorktree({
+            baseRepo: repo,
+            fleetName: spec.fleet_name,
+            fleetRoot,
+            branches: orderedWorktreeBranches(spec),
+          });
+          if (!prep.ok) {
+            await patch(w.id, {
+              status: "failed",
+              ended_at: new Date().toISOString(),
+              status_note: prep.conflict,
+            });
+            continue;
+          }
+        }
+
         await patch(w.id, { status: "running", started_at: new Date().toISOString() });
         const p = opts.spawn(w.id).then(async (res) => {
           if (opts.killSwitch?.killed) return;
@@ -133,6 +225,27 @@ export async function runFleet(opts: RunFleetOpts): Promise<FleetState> {
             await patch(w.id, { status: "failed", ended_at: new Date().toISOString(), turns: res.turns, tokens: res.tokens, cost_usd_estimate: res.cost ?? 0 });
             return;
           }
+          if (w.worktree) {
+            try {
+              await commitWorktree({
+                worktreePath: repoCwdFor(w.id),
+                nodeId: w.id,
+                fleetName: spec.fleet_name,
+                iteration: state.iteration,
+              });
+            } catch (e) {
+              const msg = e instanceof Error ? e.message : String(e);
+              await patch(w.id, {
+                status: "failed",
+                ended_at: new Date().toISOString(),
+                turns: res.turns,
+                tokens: res.tokens,
+                cost_usd_estimate: res.cost ?? 0,
+                status_note: `commit failed: ${msg}`,
+              });
+              return;
+            }
+          }
           const contract = await verifyOutputs({
             workerDir: `${fleetRoot}/workers/${w.id}`,
             repoCwd: repoCwdFor(w.id),

package/src/worktree.ts

@@ -0,0 +1,75 @@
+import { execFile } from "node:child_process";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+
+const execFileP = promisify(execFile);
+
+export interface CreateWorktreeOpts {
+  baseRepo: string;
+  fleetName: string;
+  nodeId: string;
+  fleetRoot: string;
+}
+
+export async function createWorktree(opts: CreateWorktreeOpts): Promise<string> {
+  const path = join(opts.fleetRoot, "worktrees", opts.nodeId);
+  const branch = `fleet/${opts.fleetName}/${opts.nodeId}`;
+  await mkdir(path, { recursive: true });
+  await removeWorktree(path, opts.baseRepo);
+  await execFileP("git", ["worktree", "add", "-b", branch, path], { cwd: opts.baseRepo });
+  return path;
+}
+
+export interface CommitWorktreeOpts {
+  worktreePath: string;
+  nodeId: string;
+  fleetName: string;
+  iteration: number;
+}
+
+export async function commitWorktree(opts: CommitWorktreeOpts): Promise<void> {
+  await execFileP("git", ["add", "-A"], { cwd: opts.worktreePath });
+  try {
+    await execFileP(
+      "git",
+      ["commit", "-m", `fleet: ${opts.fleetName} ${opts.nodeId} iteration ${opts.iteration}`],
+      { cwd: opts.worktreePath },
+    );
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (msg.includes("nothing to commit")) return;
+    throw e;
+  }
+}
+
+export interface PrepareIntegratorOpts {
+  baseRepo: string;
+  fleetName: string;
+  fleetRoot: string;
+  branches: string[];
+}
+
+export async function prepareIntegratorWorktree(
+  opts: PrepareIntegratorOpts,
+): Promise<{ path: string; ok: boolean; conflict?: string }> {
+  const path = join(opts.fleetRoot, "worktrees", "fleet-integrator");
+  await removeWorktree(path, opts.baseRepo);
+  await mkdir(path, { recursive: true });
+  await execFileP("git", ["worktree", "add", "-b", `fleet/${opts.fleetName}/fleet-integrator`, path], {
+    cwd: opts.baseRepo,
+  });
+  for (const branch of opts.branches) {
+    try {
+      await execFileP("git", ["merge", "--no-ff", "--no-edit", branch], { cwd: path });
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      return { path, ok: false, conflict: `merge ${branch} failed: ${msg}` };
+    }
+  }
+  return { path, ok: true };
+}
+
+export async function removeWorktree(path: string, baseRepo: string): Promise<void> {
+  await execFileP("git", ["worktree", "remove", "--force", path], { cwd: baseRepo }).catch(() => {});
+}