jules-orchestrator-kit 0.3.0 → 0.5.2

package/scripts/jules-queue-runner.mjs

@@ -1,7 +1,11 @@
 import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { execFileSync } from "node:child_process";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { log, ensureDir, sleep } from "./utils.mjs";
+
+const execFileAsync = promisify(execFile);
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -18,13 +22,8 @@ if (!fs.existsSync(queueDir)) {
   process.exit(1);
 }
 
-if (!fs.existsSync(completedDir)) {
-  fs.mkdirSync(completedDir, { recursive: true });
-}
-
-if (!fs.existsSync(processingDir)) {
-  fs.mkdirSync(processingDir, { recursive: true });
-}
+ensureDir(completedDir);
+ensureDir(processingDir);
 
 function logQueueState(file, status, error = null) {
   const entry = JSON.stringify({
@@ -41,45 +40,100 @@ const files = fs.readdirSync(queueDir).filter(
 );
 
 if (files.length === 0) {
-  console.log("ℹ️ No tasks found in the queue.");
+  log.info("No tasks found in the queue.");
   process.exit(0);
 }
 
-console.log(`🐝 Found ${files.length} tasks in the queue. Processing...`);
+log.info(`🚀 Found ${files.length} tasks in the queue. Sending to Jules...`);
+
+const MAX_CONCURRENT = parseInt(process.env.JULES_SWARM_CONCURRENCY || "3", 10) || 3;
 
-files.forEach((file, index) => {
-  const filePath = path.join(queueDir, file);
-  const processingPath = path.join(processingDir, file);
-  
-  // Atomic claim: move from queueDir to processingDir before dispatching
+const args = process.argv.slice(2);
+let paceMs = parseInt(process.env.JULES_PACE_MS || "500", 10);
+const paceIdx = args.indexOf("--pace-ms");
+if (paceIdx !== -1 && args[paceIdx + 1]) {
+  const parsed = parseInt(args[paceIdx + 1], 10);
+  if (Number.isFinite(parsed) && parsed >= 0) paceMs = parsed;
+}
+
+function safeMoveSync(src, dest) {
   try {
-    fs.renameSync(filePath, processingPath);
-  } catch (claimErr) {
-    // Another runner already claimed this task file
-    return;
+    fs.renameSync(src, dest);
+  } catch (err) {
+    if (err.code === "EXDEV") {
+      fs.copyFileSync(src, dest);
+      fs.unlinkSync(src);
+    } else {
+      throw err;
+    }
   }
+}
 
-  // Generate title from filename (e.g. "TASK-001-auth-spec.md" -> "TASK 001 auth spec")
-  const title = file.replace(/\.md$/, "").replace(/-/g, " ");
-  
-  console.log(`\n----------------------------------------`);
-  console.log(`[${index + 1}/${files.length}] Dispatching queued task: ${title}`);
-  logQueueState(file, "RUNNING");
-  
+async function safeMoveAsync(src, dest) {
   try {
-    execFileSync("node", [dispatchScript, title, processingPath], {
-      stdio: "inherit",
-    });
-    
-    // Move to completed
-    const destPath = path.join(completedDir, file);
-    fs.renameSync(processingPath, destPath);
-    logQueueState(file, "COMPLETED");
-    console.log(`✅ Moved ${file} to completed/`);
-  } catch (error) {
-    logQueueState(file, "FAILED", error);
-    console.error(`⚠️ Failed to dispatch task [${title}]:`, error.message);
+    await fs.promises.rename(src, dest);
+  } catch (err) {
+    if (err.code === "EXDEV") {
+      await fs.promises.copyFile(src, dest);
+      await fs.promises.unlink(src);
+    } else {
+      throw err;
+    }
   }
-});
+}
+
+async function runQueue() {
+  for (let i = 0; i < files.length; i += MAX_CONCURRENT) {
+    const batch = files.slice(i, i + MAX_CONCURRENT);
+    await Promise.allSettled(
+      batch.map(async (file, bIdx) => {
+        if (bIdx > 0 && paceMs > 0) {
+          await sleep(bIdx * paceMs);
+        }
+        const index = i + bIdx;
+        const filePath = path.join(queueDir, file);
+        const processingPath = path.join(processingDir, file);
+        
+        // Atomic claim: move from queueDir to processingDir before dispatching
+        try {
+          safeMoveSync(filePath, processingPath);
+        } catch (claimErr) {
+          // Another runner already claimed this task file or file missing
+          return;
+        }
+
+        const title = file.replace(/\.md$/, "").replace(/-/g, " ");
+        
+        const content = fs.readFileSync(processingPath, "utf-8").trim();
+        if (!content || content.length < 10) {
+          log.warn(`Task file ${file} is empty or invalid. Skipping dispatch.`);
+          const destPath = path.join(completedDir, file);
+          await safeMoveAsync(processingPath, destPath);
+          logQueueState(file, "SKIPPED_INVALID");
+          return;
+        }
+
+        log.step(`[${index + 1}/${files.length}]`, `🚀 Sending task to Jules: ${title}`);
+        logQueueState(file, "RUNNING");
+        
+        try {
+          await execFileAsync("node", [dispatchScript, title, processingPath]);
+          
+          const destPath = path.join(completedDir, file);
+          await safeMoveAsync(processingPath, destPath);
+          logQueueState(file, "DISPATCHED");
+          log.success(`Task dispatched successfully (Moved ${file} to completed/)`);
+        } catch (error) {
+          logQueueState(file, "FAILED", error);
+          log.error(`Failed to dispatch task [${title}]: ${error.message}`);
+        }
+      })
+    );
+  }
+  log.header("Queue processing complete!");
+}
 
-console.log(`\n🎉 Queue processing complete!`);
+runQueue().catch(err => {
+  log.error(`Fatal queue error: ${err.message}`);
+  process.exit(1);
+});

package/scripts/jules-scan-todos.mjs

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+/**
+ * Suggested Tasks Scanner for Google Jules
+ * Scans codebase for TODO, FIXME, HACK, and OPTIMIZE comments, ranks them by priority,
+ * and generates a tasks JSON file formatted for jules-swarm or jules-dispatch.
+ * Zero external dependencies.
+ */
+
+import fs from "node:fs";
+import path from "node:path";
+import { log, ensureDir } from "./utils.mjs";
+
+const IGNORE_DIRS = new Set([
+  "node_modules",
+  ".git",
+  ".agent/history",
+  ".agent/worktrees",
+  ".agent/jules-queue/.processing",
+  ".agent/jules-queue/completed",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".turbo",
+  "tmp_repos",
+  "tmp_repos2",
+  "tmp_repos3"
+]);
+
+const IGNORE_EXTS = new Set([
+  ".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif", ".ico", ".pdf",
+  ".zip", ".tar", ".gz", ".7z", ".mp4", ".webm", ".mp3", ".wav",
+  ".lock", ".map", ".bin", ".exe"
+]);
+
+const TAG_REGEX = /(?:(?:\/\/|\/\*|\*|#|<!--)\s*|\b)(FIXME|HACK|TODO|OPTIMIZE):?\s*(.+)$/;
+
+export function scanCodebaseForTodos(rootDir = process.cwd(), options = {}) {
+  const tasks = [];
+  const maxTasks = options.maxTasks || 100;
+
+  function walk(currentDir) {
+    if (tasks.length >= maxTasks) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(currentDir, { withFileTypes: true });
+    } catch (_) {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (tasks.length >= maxTasks) break;
+      const fullPath = path.join(currentDir, entry.name);
+      const relPath = path.relative(rootDir, fullPath).replace(/\\/g, "/");
+
+      if (entry.isDirectory()) {
+        const baseName = entry.name;
+        if (IGNORE_DIRS.has(baseName) || IGNORE_DIRS.has(relPath) || baseName.startsWith(".")) {
+          continue;
+        }
+        walk(fullPath);
+      } else if (entry.isFile()) {
+        const ext = path.extname(entry.name).toLowerCase();
+        if (IGNORE_EXTS.has(ext)) continue;
+
+        try {
+          const content = fs.readFileSync(fullPath, "utf-8");
+          const lines = content.split("\n");
+          for (let lineIdx = 0; lineIdx < lines.length; lineIdx++) {
+            const line = lines[lineIdx];
+            // Ignore false positives from regex definitions, test assertions, or scanner string literals
+            if (/TAG_REGEX|assert\.|tasks\.some|log\.info\("Zero TODO|\/FIXME comments/i.test(line)) {
+              continue;
+            }
+            const match = line.match(TAG_REGEX);
+            if (match) {
+              const tag = match[1].toUpperCase();
+              const text = match[2].trim();
+              const priority = (tag === "FIXME" || tag === "HACK") ? "HIGH" : "MEDIUM";
+              const taskId = `task-${tag.toLowerCase()}-${tasks.length + 1}`;
+
+              tasks.push({
+                id: taskId,
+                title: `${tag} in ${path.basename(relPath)}: ${text.slice(0, 50)}`,
+                priority,
+                prompt: `Resolve ${tag} comment in \`${relPath}\` at line ${lineIdx + 1}.\n\nComment: ${text}\n\nFile Context:\n\`\`\`\nLine ${lineIdx + 1}: ${line.trim()}\n\`\`\``,
+                file: relPath,
+                line: lineIdx + 1,
+                tag
+              });
+
+              if (tasks.length >= maxTasks) break;
+            }
+          }
+        } catch (_) {
+          // Skip unreadable files
+        }
+      }
+    }
+  }
+
+  walk(rootDir);
+  return tasks;
+}
+
+export function runScanner() {
+  const args = process.argv.slice(2);
+  const isJson = args.includes("--json");
+
+  let outputPath = path.resolve(process.cwd(), ".agent/jules-queue/suggested-tasks.json");
+  const outIdx = args.indexOf("--output");
+  if (outIdx !== -1 && args[outIdx + 1]) {
+    outputPath = path.resolve(process.cwd(), args[outIdx + 1]);
+  }
+
+  log.header("Suggested Tasks Scanner");
+  log.info(`Scanning codebase for TODO, FIXME, HACK, and OPTIMIZE comments...`);
+
+  const tasks = scanCodebaseForTodos(process.cwd());
+
+  if (isJson) {
+    console.log(JSON.stringify(tasks, null, 2));
+    return;
+  }
+
+  log.success(`Scanned and found ${tasks.length} suggested task(s).`);
+
+  if (tasks.length === 0) {
+    log.info("Zero TODO/FIXME comments found in codebase!");
+    return;
+  }
+
+  ensureDir(path.dirname(outputPath));
+  fs.writeFileSync(outputPath, JSON.stringify(tasks, null, 2), "utf-8");
+
+  log.success(`Generated suggested tasks file: ${path.relative(process.cwd(), outputPath)}`);
+  log.info(`Run \`npx jules-swarm ${path.relative(process.cwd(), outputPath)}\` to execute all tasks in parallel.`);
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === path.resolve(import.meta.url.slice(7))) {
+  runScanner();
+}

package/scripts/jules-self-audit.mjs

@@ -1,17 +1,19 @@
-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);
-    process.exit(1);
+    const err = new Error(`Git command failed: git ${args.join(" ")}\n${error.message}`);
+    err.code = 1;
+    throw err;
   }
 }
 
@@ -145,32 +147,48 @@ 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);
+    const err = new Error(`FATAL: Invalid BASE_BRANCH "${targetBranch}". Must match ^[a-zA-Z0-9._\\/-]+$`);
+    err.code = 2;
+    throw err;
+  }
+  log.info(`Target Branch: ${targetBranch}`);
+
+  try {
+    execFileSync("git", ["--version"], { stdio: "ignore" });
+  } catch {
+    const err = new Error("FATAL: git is not installed or not in PATH.");
+    err.code = 2;
+    throw err;
   }
-  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);
+    const err = new Error(`FATAL: Could not compute merge-base with ${mainRef}. Make sure git history is unshallowed.`);
+    err.code = 2;
+    throw err;
   }
 
-  console.log(`🔗 Merge-Base Hash: ${mergeBase}`);
+  log.info(`Merge-Base Hash: ${mergeBase}`);
 
-  const rawDiffFiles = runCommand(`git diff -z --name-only ${mergeBase}...HEAD`)
+  const rawDiffFiles = runGitCommand(["diff", "-z", "--name-only", `${mergeBase}...HEAD`])
     .split("\0")
     .map((f) => f.trim().replace(/^["']|["']$/g, ""))
     .filter(Boolean);
@@ -178,12 +196,12 @@ export function runSelfAudit() {
   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);
 
@@ -195,16 +213,15 @@ 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);
+    const err = new Error("RESTRICTED FILE VIOLATION DETECTED!");
+    err.code = 3;
+    throw err;
   }
-  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;
@@ -221,24 +238,24 @@ 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.");
-    runCommand("git status");
+    log.info("No build or test scripts found. Running git status check.");
+    execSync("git status", { stdio: "inherit" });
   }
 
   const durationMs = Date.now() - startTime;
@@ -251,17 +268,132 @@ 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));
+
+    if (process.env.CI && !process.env.ALLOW_AUTO_REPAIR) {
+      const err = new Error("CI environment detected and ALLOW_AUTO_REPAIR is not set. Failing fast to save CI minutes.");
+      err.code = 4;
+      throw err;
+    }
+
+    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.");
+    }
+    const err = new Error("OODA Auto-Repair failed or exhausted.");
+    err.code = 4;
+    throw err;
   }
 
-  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 (Sterile Simulation)...");
+  
+  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/5]", `Creating isolated environment in ${sandboxDir}...`);
+    fs.mkdirSync(sandboxDir, { recursive: true });
+    
+    execSync(`git archive HEAD -o "${tempArchive}"`);
+    execSync(`tar -xf "${tempArchive}" -C "${sandboxDir}"`);
+    
+    log.step("[2/5]", "Sterilizing environment variables...");
+    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/5]", "Installing dependencies in sandbox (npm ci)...");
+    const packageJsonPath = path.join(sandboxDir, "package.json");
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        execSync("npm ci --ignore-scripts", { cwd: sandboxDir, stdio: "ignore" });
+      } catch (e) {
+        log.warn("npm ci failed or wasn't needed. Proceeding...");
+      }
+    }
+
+    log.step("[4/5]", "Resolving execution boundary in sandbox...");
+    const resolvedCmds = resolveWorkspaceExecutionBoundary([], sandboxDir);
+    
+    if (resolvedCmds.testCmd || resolvedCmds.buildCmd) {
+      log.step("[5/5]", `Running verification: ${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("No test/build commands found for verification.");
+      log.success("Pre-Flight Passed (No-Op).");
+    }
+  } catch (err) {
+    log.error("\nPRE-FLIGHT FAILED!");
+    log.error("The agent would likely crash (The 5-Minute Drop-off) in the Web UI due to missing dependencies.");
+    const wrappedErr = new Error(err.message);
+    wrappedErr.code = 1;
+    throw wrappedErr;
+  } 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();
+  try {
+    if (process.argv.includes("--preflight")) {
+      runPreflightSandbox();
+    } else {
+      runSelfAudit();
+    }
+  } catch (err) {
+    if (err.message) log.error(err.message);
+    process.exit(err.code || 1);
+  }
 }
 
 

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);
+}