jules-orchestrator-kit 0.2.9 → 0.5.1

package/scripts/jules-self-audit.mjs

@@ -1,23 +1,28 @@
-import { execSync } from "node:child_process";
+import { execSync, execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import crypto from "node:crypto";
+import os from "node:os";
 import { fileURLToPath } from "node:url";
 import { resolveWorkspaceExecutionBoundary } from "./command-resolver.mjs";
+import { log, logToHistory } from "./utils.mjs";
 
-function runCommand(cmd, ignoreError = false) {
+function runGitCommand(args, ignoreError = false) {
   try {
-    return execSync(cmd, { encoding: "utf-8" }).trim();
+    return execFileSync("git", args, { encoding: "utf-8" }).trim();
   } catch (error) {
     if (ignoreError) return "";
-    console.error(`❌ Command failed: ${cmd}`);
-    console.error(error.message);
+    log.error(`Git command failed: git ${args.join(" ")}`);
+    log.error(error.message);
     process.exit(1);
   }
 }
 
 export function matchGlob(filepath, globPattern) {
   const cleanPath = filepath.replace(/\\/g, "/").replace(/^\.\//, "");
-  const segments = globPattern.split("/");
+  // Normalize consecutive glob wildcards (e.g., "**/**" -> "**")
+  const normalizedGlob = globPattern.replace(/\\/g, "/").replace(/(?:\*\*\/)+/g, "**/");
+  const segments = normalizedGlob.split("/");
   const regexParts = [];
   for (let i = 0; i < segments.length; i++) {
     const seg = segments[i];
@@ -33,12 +38,14 @@ export function matchGlob(filepath, globPattern) {
     }
   }
   let patternStr = regexParts.join("/");
-  patternStr = patternStr.replace(/(^|\/)\*\*(\/|$)/g, (m, p1, p2) => {
-    if (p1 === "/" && p2 === "/") return "(?:/|/.*/)";
-    if (p1 === "/") return "(?:/.*)?";
-    if (p2 === "/") return "(?:.*/)?";
+  patternStr = patternStr.replace(/(?:^|\/)\*\*(?:\/|$)/g, (m) => {
+    if (m === "**") return ".*";
+    if (m === "/**/") return "(?:/|/.*/)";
+    if (m === "/**") return "(?:/.*)?";
+    if (m === "**/") return "(?:.*/)?";
     return ".*";
   });
+  patternStr = patternStr.replace(/\*\*/g, ".*");
   return new RegExp(`^${patternStr}$`, "i").test(cleanPath);
 }
 
@@ -141,45 +148,58 @@ export function logAuditMetrics(metrics) {
 }
 
 export function runSelfAudit() {
-  console.log("🔍 Running Jules PR Self-Audit Gatekeeper...\n");
+  log.header("Running Jules PR Self-Audit Gatekeeper...");
 
   const targetBranch = process.env.BASE_BRANCH || "main";
   const SAFE_BRANCH = /^[a-zA-Z0-9._\/-]+$/;
   if (!SAFE_BRANCH.test(targetBranch)) {
-    console.error(`❌ FATAL: Invalid BASE_BRANCH "${targetBranch}". Must match ^[a-zA-Z0-9._\\/-]+$`);
-    process.exit(1);
+    log.error(`FATAL: Invalid BASE_BRANCH "${targetBranch}". Must match ^[a-zA-Z0-9._\\/-]+$`);
+    process.exit(2);
+  }
+  log.info(`Target Branch: ${targetBranch}`);
+
+  try {
+    execFileSync("git", ["--version"], { stdio: "ignore" });
+  } catch {
+    log.error("FATAL: git is not installed or not in PATH.");
+    process.exit(2);
   }
-  console.log(`🎯 Target Branch: ${targetBranch}`);
 
   if (process.env.CI) {
-    console.log("☁️ CI environment detected. Fetching merge-base history...");
-    runCommand(`git fetch origin ${targetBranch} --depth=100 || git fetch origin ${targetBranch} --unshallow`, true);
+    log.info("☁️ CI environment detected. Fetching merge-base history...");
+    runGitCommand(["fetch", "origin", targetBranch, "--depth=100"], true);
+    const tmpRef = runGitCommand(["rev-parse", "--verify", `origin/${targetBranch}`], true) ? `origin/${targetBranch}` : targetBranch;
+    const tmpMerge = runGitCommand(["merge-base", "HEAD", tmpRef], true);
+    if (!tmpMerge) {
+      log.warn("Shallow fetch failed to find merge-base, executing full unshallow...");
+      runGitCommand(["fetch", "origin", targetBranch, "--unshallow"], true);
+    }
   }
 
-  const mainRef = runCommand(`git rev-parse --verify origin/${targetBranch}`, true) ? `origin/${targetBranch}` : targetBranch;
-  const mergeBase = runCommand(`git merge-base HEAD ${mainRef}`, true);
+  const mainRef = runGitCommand(["rev-parse", "--verify", `origin/${targetBranch}`], true) ? `origin/${targetBranch}` : targetBranch;
+  const mergeBase = runGitCommand(["merge-base", "HEAD", mainRef], true);
 
   if (!mergeBase) {
-    console.error(`❌ FATAL: Could not compute merge-base with ${mainRef}. Make sure git history is unshallowed.`);
-    process.exit(1);
+    log.error(`FATAL: Could not compute merge-base with ${mainRef}. Make sure git history is unshallowed.`);
+    process.exit(2);
   }
 
-  console.log(`🔗 Merge-Base Hash: ${mergeBase}`);
+  log.info(`Merge-Base Hash: ${mergeBase}`);
 
-  const rawDiffFiles = runCommand(`git diff --name-only ${mergeBase}...HEAD`)
-    .split("\n")
-    .map((f) => f.trim())
+  const rawDiffFiles = runGitCommand(["diff", "-z", "--name-only", `${mergeBase}...HEAD`])
+    .split("\0")
+    .map((f) => f.trim().replace(/^["']|["']$/g, ""))
     .filter(Boolean);
 
   const isBloatFile = (file) => /(\.lock|package-lock\.json|yarn\.lock|pnpm-lock\.yaml|\.png|\.jpg|\.jpeg|\.pdf|\.min\.js|\.map)$/i.test(file);
   const changedCodeFiles = rawDiffFiles.filter((f) => !isBloatFile(f));
 
-  console.log(`\n📄 Modified Code Files (${changedCodeFiles.length} of ${rawDiffFiles.length} total changes):`);
-  changedCodeFiles.forEach((file) => console.log(`   - ${file}`));
+  log.info(`Modified Code Files (${changedCodeFiles.length} of ${rawDiffFiles.length} total changes):`);
+  changedCodeFiles.forEach((file) => log.dim(`   - ${file}`));
 
   // Fail closed: Load security config exclusively from base branch (mainRef).
   // Never fall back to working-tree config which an untrusted PR could craft.
-  const trustedConfig = runCommand(`git show ${mainRef}:.agent/jules.yml`, true);
+  const trustedConfig = runGitCommand(["show", `${mainRef}:.agent/jules.yml`], true);
   const forbiddenPatterns = loadForbiddenPatterns(trustedConfig);
   const allowedPatterns = loadAllowedPatterns(trustedConfig);
 
@@ -191,16 +211,16 @@ export function runSelfAudit() {
   });
 
   if (violations.length > 0) {
-    console.error("\n❌ RESTRICTED FILE VIOLATION DETECTED!");
-    console.error("Jules PR attempted to modify forbidden system files:");
-    violations.forEach((v) => console.error(`   - ${v}`));
-    process.exit(1);
+    log.error("RESTRICTED FILE VIOLATION DETECTED!");
+    log.error("Jules PR attempted to modify forbidden system files:");
+    violations.forEach((v) => log.error(`   - ${v}`));
+    process.exit(3);
   }
-  console.log("\n✅ Restricted File Boundary Check: PASSED");
+  log.success("Restricted File Boundary Check: PASSED");
 
-  console.log("\n🛠️ Resolving Dynamic Verification Suite...");
+  log.info("Resolving Dynamic Verification Suite...");
   const resolvedCmds = resolveWorkspaceExecutionBoundary(changedCodeFiles, process.cwd());
-  console.log(`📋 Discovered Execution Scope: ${resolvedCmds.source}`);
+  log.info(`Discovered Execution Scope: ${resolvedCmds.source}`);
 
   const startTime = Date.now();
   let testPassed = true;
@@ -217,23 +237,23 @@ export function runSelfAudit() {
   };
 
   if (resolvedCmds.testCmd) {
-    console.log(`▶ Running Test Verification: ${resolvedCmds.testCmd}`);
+    log.step("▶", `Running Test Verification: ${resolvedCmds.testCmd}`);
     if (!runVerification(resolvedCmds.testCmd)) {
       testPassed = false;
-      console.error(`❌ Test verification failed: ${resolvedCmds.testCmd}`);
+      log.error(`Test verification failed: ${resolvedCmds.testCmd}`);
     }
   }
 
   if (testPassed && resolvedCmds.buildCmd) {
-    console.log(`▶ Running Build Verification: ${resolvedCmds.buildCmd}`);
+    log.step("▶", `Running Build Verification: ${resolvedCmds.buildCmd}`);
     if (!runVerification(resolvedCmds.buildCmd)) {
       testPassed = false;
-      console.error(`❌ Build verification failed: ${resolvedCmds.buildCmd}`);
+      log.error(`Build verification failed: ${resolvedCmds.buildCmd}`);
     }
   }
 
   if (!resolvedCmds.testCmd && !resolvedCmds.buildCmd) {
-    console.log("ℹ️ No build or test scripts found. Running git status check.");
+    log.info("No build or test scripts found. Running git status check.");
     runCommand("git status");
   }
 
@@ -247,17 +267,150 @@ export function runSelfAudit() {
   });
 
   if (!testPassed) {
-    console.error("\n🔄 OODA SELF-HEALING FEEDBACK LOG:");
-    console.error(failureLog.slice(-1500));
-    process.exit(1);
+    log.error("OODA SELF-HEALING FEEDBACK LOG:");
+    log.dim(failureLog.slice(-1500));
+
+    // OODA Circuit Breaker: Fingerprint failure trace using SHA-256
+    const normalizedError = failureLog
+      .replace(/\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d+Z/g, "TIMESTAMP")
+      .replace(/0x[0-9a-fA-F]+/g, "HEX")
+      .replace(/\d+/g, "NUM")
+      .trim();
+    const errorHash = crypto.createHash("sha256").update(normalizedError).digest("hex");
+
+    const circuitFile = path.resolve(process.cwd(), ".agent/history/ooda-circuit.json");
+    let prevCircuit = { hash: "", count: 0 };
+    if (fs.existsSync(circuitFile)) {
+      try {
+        prevCircuit = JSON.parse(fs.readFileSync(circuitFile, "utf-8"));
+      } catch (_) {}
+    }
+
+    if (prevCircuit.hash === errorHash && prevCircuit.count >= 1) {
+      log.error("❌ OODA CIRCUIT BREAKER TRIPPED: Consecutive identical failure detected.");
+      log.error("Agent generated code with identical error trace twice in a row. Aborting auto-repair.");
+      try {
+        fs.writeFileSync(circuitFile, JSON.stringify({ hash: "", count: 0 }));
+      } catch (_) {}
+      process.exit(4);
+    }
+
+    try {
+      fs.writeFileSync(
+        circuitFile,
+        JSON.stringify({
+          hash: errorHash,
+          count: prevCircuit.hash === errorHash ? prevCircuit.count + 1 : 1,
+          updatedAt: new Date().toISOString()
+        })
+      );
+    } catch (_) {}
+
+    if (process.env.CI && !process.env.ALLOW_AUTO_REPAIR) {
+      log.error("CI environment detected and ALLOW_AUTO_REPAIR is not set. Failing fast to save CI minutes.");
+      process.exit(4);
+    }
+
+    let oodaRetries = 0;
+    try {
+      const history = execSync("git log -n 5 --format=%B", { encoding: "utf-8" });
+      const matches = history.match(/OODA Auto-Repair/gi);
+      if (matches) {
+        oodaRetries = matches.length;
+      }
+    } catch (e) {
+      // Ignorera git-fel här
+    }
+
+    if (oodaRetries < 3) {
+      log.info(`🛠️ Initiating OODA Auto-Repair (Attempt ${oodaRetries + 1}/3)...`);
+      const prompt = `OODA Auto-Repair Attempt ${oodaRetries + 1}\n\nThe verification suite failed with the following errors after the previous patch:\n\n\`\`\`\n${failureLog.slice(-1500)}\n\`\`\`\n\nPlease fix the errors so the verification passes.`;
+      
+      const dispatchScript = path.resolve(process.cwd(), "scripts/jules-dispatch.mjs");
+      try {
+        const env = { 
+          ...process.env, 
+          BASE_BRANCH: process.env.GITHUB_HEAD_REF || targetBranch 
+        };
+        execFileSync("node", [dispatchScript, "OODA Auto-Repair", prompt], {
+          stdio: "inherit",
+          env
+        });
+      } catch (dispatchErr) {
+        log.error(`Failed to trigger OODA repair dispatch: ${dispatchErr.message}`);
+      }
+    } else {
+      log.error("❌ OODA Auto-Repair exhausted maximum retries (3). Giving up.");
+    }
+    
+    process.exit(4);
   }
 
-  console.log("\n🎉 JULES PR SELF-AUDIT PASSED SUCCESSFULLY!");
+  log.success("🎉 JULES PR SELF-AUDIT PASSED SUCCESSFULLY!");
+}
+
+export function runPreflightSandbox() {
+  log.header("Initializing Pre-Flight Sandbox (Steril Simulering)...");
+  
+  const runId = crypto.randomBytes(4).toString("hex");
+  const sandboxDir = path.join(os.tmpdir(), `jules-preflight-${runId}`);
+  const tempArchive = path.join(os.tmpdir(), `jules-archive-${runId}.tar`);
+  
+  try {
+    log.step("[1/4]", `Skapar isolerad miljö i ${sandboxDir}...`);
+    fs.mkdirSync(sandboxDir, { recursive: true });
+    
+    execSync(`git archive HEAD -o "${tempArchive}"`);
+    execSync(`tar -xf "${tempArchive}" -C "${sandboxDir}"`);
+    
+    log.step("[2/4]", "Steriliserar miljövariabler...");
+    const sterileEnv = { ...process.env };
+    const stripKeys = ["DATABASE_URL", "NPM_TOKEN", "GITHUB_TOKEN", "GH_TOKEN", "AWS_ACCESS_KEY_ID", "STRIPE_TEST_KEY"];
+    for (const key of stripKeys) {
+      if (sterileEnv[key]) {
+        sterileEnv[key] = `mock-${key.toLowerCase()}`;
+      }
+    }
+    
+    log.step("[3/4]", "Löser beroenden i sandlådan...");
+    const resolvedCmds = resolveWorkspaceExecutionBoundary([], sandboxDir);
+    
+    if (resolvedCmds.testCmd || resolvedCmds.buildCmd) {
+      log.step("[4/4]", `Kör verifiering: ${resolvedCmds.testCmd || resolvedCmds.buildCmd}`);
+      execSync(resolvedCmds.testCmd || resolvedCmds.buildCmd, {
+        cwd: sandboxDir,
+        env: sterileEnv,
+        stdio: "inherit"
+      });
+      log.success("Pre-Flight Passed. Zero epistemic drift detected.");
+    } else {
+      log.info("Inga test/bygg-kommandon hittades för verifiering.");
+      log.success("Pre-Flight Passed (No-Op).");
+    }
+  } catch (err) {
+    log.error("\nPRE-FLIGHT MISSLYCKADES!");
+    log.error("Agenten skulle förmodligen krascha (The 5-Minute Drop-off) i Web UI på grund av saknade beroenden.");
+    log.error(err.message);
+    process.exit(1);
+  } finally {
+    try {
+      fs.rmSync(sandboxDir, { recursive: true, force: true });
+      if (fs.existsSync(tempArchive)) {
+        fs.rmSync(tempArchive, { force: true });
+      }
+    } catch (e) {
+      // Ignorera fel vid cleanup
+    }
+  }
 }
 
 // Execute when invoked directly from CLI
 if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(fileURLToPath(import.meta.url))) {
-  runSelfAudit();
+  if (process.argv.includes("--preflight")) {
+    runPreflightSandbox();
+  } else {
+    runSelfAudit();
+  }
 }
 
 

package/scripts/jules-status.mjs

@@ -0,0 +1,57 @@
+#!/usr/bin/env node
+/**
+ * Jules Task Status Utility
+ * Parses the queue.jsonl file and renders a clean console.table
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { log } from "./utils.mjs";
+
+const queueLogPath = path.resolve(process.cwd(), ".agent/jules-queue/queue.jsonl");
+
+if (!fs.existsSync(queueLogPath)) {
+  log.info("Queue log is empty. No tasks have been dispatched yet.");
+  process.exit(0);
+}
+
+try {
+  const content = fs.readFileSync(queueLogPath, "utf-8");
+  const lines = content.split("\n").filter(Boolean);
+  
+  if (lines.length === 0) {
+    log.info("Queue log is empty.");
+    process.exit(0);
+  }
+
+  // We only want the latest status for each task file
+  const statusMap = new Map();
+
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.file) {
+        statusMap.set(entry.file, {
+          Task: entry.file.replace(/^TASK-\d+-/, "").replace(/\.md$/, ""),
+          Status: entry.status,
+          Timestamp: new Date(entry.timestamp).toLocaleString(),
+          Error: entry.error || "-"
+        });
+      }
+    } catch (e) {
+      // Ignore malformed lines
+    }
+  }
+
+  if (statusMap.size === 0) {
+    log.info("No parseable task events found in queue.jsonl");
+    process.exit(0);
+  }
+
+  log.header("Jules Queue Status");
+  console.table(Array.from(statusMap.values()));
+
+} catch (err) {
+  log.error(`Failed to read queue log: ${err.message}`);
+  process.exit(1);
+}

package/scripts/jules-swarm.mjs

@@ -2,26 +2,27 @@ import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import fs from "node:fs";
 import path from "node:path";
+import { log, sleep } from "./utils.mjs";
 
 const execFileAsync = promisify(execFile);
 
 const tasksFile = process.argv[2];
 
 if (!tasksFile) {
-  console.error("Usage: node scripts/jules-swarm.mjs <path-to-tasks.json>");
-  console.error('Format of tasks.json: [ { "id": "t1", "title": "Task 1", "prompt": "Description 1", "scope": ["src/moduleA/**"] } ]');
+  log.error("Usage: node scripts/jules-swarm.mjs <path-to-tasks.json>");
+  log.error('Format of tasks.json: [ { "id": "t1", "title": "Task 1", "prompt": "Description 1", "scope": ["src/moduleA/**"] } ]');
   process.exit(1);
 }
 
 const resolvedPath = path.resolve(process.cwd(), tasksFile);
 if (!fs.existsSync(resolvedPath)) {
-  console.error(`❌ Tasks file not found: ${resolvedPath}`);
+  log.error(`Tasks file not found: ${resolvedPath}`);
   process.exit(1);
 }
 
 const tasks = JSON.parse(fs.readFileSync(resolvedPath, "utf-8"));
 if (!Array.isArray(tasks)) {
-  console.error("❌ tasks.json must contain a JSON array of task objects.");
+  log.error("tasks.json must contain a JSON array of task objects.");
   process.exit(1);
 }
 
@@ -36,48 +37,119 @@ const USE_WORKTREES = process.env.JULES_USE_WORKTREES === "true";
 // Ensure root project path is preserved for history logs even when running in worktrees
 process.env.JULES_PROJECT_ROOT = process.cwd();
 
-console.log(`🐝 Launching Jules Swarm Orchestrator (${tasks.length} tasks, Concurrency: ${MAX_CONCURRENT}, Worktrees: ${USE_WORKTREES ? "ENABLED" : "DISABLED"})...`);
+log.info(`Launching Jules Swarm Orchestrator (${tasks.length} tasks, Concurrency: ${MAX_CONCURRENT}, Worktrees: ${USE_WORKTREES ? "ENABLED" : "DISABLED"})...`);
 
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const activeWorktrees = new Set();
+
+function cleanupAllWorktreesSync() {
+  for (const item of Array.from(activeWorktrees)) {
+    if (item.wtDir && fs.existsSync(item.wtDir)) {
+      try {
+        fs.chmodSync(item.wtDir, 0o755);
+      } catch (_) {}
+    }
+    try {
+      execFileSync("git", ["worktree", "remove", "--force", item.wtDir], { stdio: "ignore" });
+    } catch (_) {}
+    if (item.branchName) {
+      try {
+        execFileSync("git", ["branch", "-D", item.branchName], { stdio: "ignore" });
+      } catch (_) {}
+    }
+  }
+  activeWorktrees.clear();
+}
+
+function reapOrphanedWorktrees() {
+  const worktreesBase = path.resolve(process.cwd(), ".agent/worktrees");
+  if (!fs.existsSync(worktreesBase)) return;
+  try {
+    const entries = fs.readdirSync(worktreesBase);
+    for (const entry of entries) {
+      const wtPath = path.join(worktreesBase, entry);
+      try {
+        execFileSync("git", ["worktree", "remove", "--force", wtPath], { stdio: "ignore" });
+      } catch (_) {
+        try {
+          fs.rmSync(wtPath, { recursive: true, force: true });
+        } catch (_) {}
+      }
+    }
+  } catch (_) {}
+  try {
+    execFileSync("git", ["worktree", "prune"], { stdio: "ignore" });
+  } catch (_) {}
+}
+
+process.on("SIGINT", () => {
+  log.dim("SIGINT received. Cleaning up active Git worktrees...");
+  cleanupAllWorktreesSync();
+  process.exit(130);
+});
+
+process.on("SIGTERM", () => {
+  log.dim("SIGTERM received. Cleaning up active Git worktrees...");
+  cleanupAllWorktreesSync();
+  process.exit(143);
+});
 
 async function createWorktree(taskId) {
   const slug = taskId.toLowerCase().replace(/[^a-z0-9]+/g, "-");
   const wtDir = path.resolve(process.cwd(), `.agent/worktrees/${slug}`);
   const branchName = `jules/${slug}`;
-  try {
-    if (!fs.existsSync(path.dirname(wtDir))) {
-      fs.mkdirSync(path.dirname(wtDir), { recursive: true });
-    }
-    await execFileAsync("git", ["worktree", "add", "-b", branchName, wtDir, "HEAD"]);
-    return { wtDir, branchName };
-  } catch (err) {
+  let item = null;
+  await fs.promises.mkdir(path.dirname(wtDir), { recursive: true });
+
+  const maxRetries = 3;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
     try {
-      await execFileAsync("git", ["worktree", "add", "--force", wtDir, "HEAD"]);
-      return { wtDir, branchName: null };
-    } catch (fallbackErr) {
-      console.warn(`⚠️ Failed to create worktree for ${taskId}:`, fallbackErr.message);
-      return null;
+      await execFileAsync("git", ["worktree", "add", "-b", branchName, wtDir, "HEAD"]);
+      item = { wtDir, branchName };
+      break;
+    } catch (err) {
+      if (attempt < maxRetries) {
+        const jitter = Math.floor(Math.random() * 200) + 100 * Math.pow(2, attempt);
+        await sleep(jitter);
+        continue;
+      }
+      try {
+        await execFileAsync("git", ["worktree", "add", "--force", wtDir, "HEAD"]);
+        item = { wtDir, branchName: null };
+      } catch (fallbackErr) {
+        log.error(`Failed to create worktree for ${taskId}: ${fallbackErr.message}`);
+        return null;
+      }
     }
   }
+  if (item) activeWorktrees.add(item);
+  return item;
 }
 
 async function removeWorktree(wtDir, branchName) {
   if (!wtDir) return;
+  for (const item of Array.from(activeWorktrees)) {
+    if (item.wtDir === wtDir) {
+      activeWorktrees.delete(item);
+    }
+  }
   try {
     await execFileAsync("git", ["worktree", "remove", "--force", wtDir]);
   } catch (err) {
-    console.warn(`⚠️ Failed to remove worktree at ${wtDir}:`, err.message);
+    log.error(`Failed to remove worktree at ${wtDir}: ${err.message}`);
   }
   if (branchName) {
     try {
       await execFileAsync("git", ["branch", "-D", branchName]);
     } catch (err) {
-      console.warn(`⚠️ Failed to delete swarm branch ${branchName}:`, err.message);
+      log.error(`Failed to delete swarm branch ${branchName}: ${err.message}`);
     }
   }
 }
 
 async function runSwarm() {
+  if (USE_WORKTREES) {
+    reapOrphanedWorktrees();
+  }
   const results = [];
   let hasFailure = false;
 
@@ -92,8 +164,7 @@ async function runSwarm() {
           await sleep(STAGGER_MS * bIdx);
         }
 
-        console.log(`\n----------------------------------------`);
-        console.log(`[${taskNum}/${tasks.length}] Dispatching Swarm Task: ${task.title} (${taskId})`);
+        log.step("======", `[${taskNum}/${tasks.length}] Dispatching Swarm Task: ${task.title} (${taskId})`);
 
         let wtInfo = null;
         let execCwd = process.cwd();
@@ -102,7 +173,7 @@ async function runSwarm() {
           wtInfo = await createWorktree(taskId);
           if (wtInfo?.wtDir) {
             execCwd = wtInfo.wtDir;
-            console.log(`🌲 Isolated Task ${taskId} in Git Worktree: ${wtInfo.wtDir}`);
+            log.info(`Isolated Task ${taskId} in Git Worktree: ${wtInfo.wtDir}`);
           }
         }
 
@@ -117,12 +188,17 @@ async function runSwarm() {
           const { stdout } = await execFileAsync("node", [dispatchScript, task.title, effectivePrompt], {
             cwd: execCwd,
             timeout: 15 * 60 * 1000,
-            env: { ...process.env, JULES_PROJECT_ROOT: process.env.JULES_PROJECT_ROOT },
+            env: {
+              ...process.env,
+              JULES_PROJECT_ROOT: process.env.JULES_PROJECT_ROOT,
+              JULES_SLOT_INDEX: String(bIdx + 1),
+              JULES_SLOT_TOTAL: String(batch.length)
+            },
           });
-          if (stdout) console.log(stdout.trim());
+          if (stdout) log.dim(stdout.trim());
           return { taskId, title: task.title, status: "SUCCESS" };
         } catch (error) {
-          console.error(`⚠️ Failed task [${task.title}]:`, error.message);
+          log.error(`Failed task [${task.title}]: ${error.message}`);
           return { taskId, title: task.title, status: "FAILED", error: error.message };
         } finally {
           if (wtInfo?.wtDir) {
@@ -143,15 +219,14 @@ async function runSwarm() {
     }
 
     if (i + MAX_CONCURRENT < tasks.length) {
-      console.log(`\n⏳ Batch finished. Cooling down for 2s before next batch...`);
+      log.info(`Batch finished. Cooling down for 2s before next batch...`);
       await sleep(2000);
     }
   }
 
-  console.log(`\n========================================`);
-  console.log(`🎉 Swarm Dispatch Summary (${results.length} tasks processed):`);
+  log.header(`Swarm Dispatch Summary (${results.length} tasks processed):`);
   results.forEach((res) => {
-    console.log(`  - [${res.status}] ${res.title}`);
+    log.info(`[${res.status}] ${res.title}`);
   });
 
   if (hasFailure) {
@@ -160,6 +235,6 @@ async function runSwarm() {
 }
 
 runSwarm().catch((err) => {
-  console.error("❌ Unhandled swarm rejection:", err);
+  log.error(`Unhandled swarm rejection: ${err.message}`);
   process.exit(1);
 });