jules-orchestrator-kit 0.8.1 → 0.9.3

package/scripts/jules-status.mjs

@@ -1,74 +1,51 @@
-import fs from "node:fs";
-import path from "node:path";
-import { log, checkDailyBudget } from "./utils.mjs";
+#!/usr/bin/env node
 
-const isJson = process.argv.includes("--json");
-const queueLogPath = path.resolve(process.cwd(), ".agent/jules-queue/queue.jsonl");
-
-const budgetInfo = checkDailyBudget();
-
-if (!fs.existsSync(queueLogPath)) {
-  if (isJson) {
-    console.log(JSON.stringify({ queue: [], budget: budgetInfo }, null, 2));
-  } else {
-    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) {
-    if (isJson) {
-      console.log(JSON.stringify({ queue: [], budget: budgetInfo }, null, 2));
-    } else {
-      log.info("Queue log is empty.");
-    }
-    process.exit(0);
-  }
+/**
+ * Backward compatibility shim for jules-status.mjs in v0.9.0.
+ */
 
-  // We only want the latest status for each task file
-  const statusMap = new Map();
+import { checkDailyBudget } from "../src/state.mjs";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
 
-  for (const line of lines) {
-    try {
-      const entry = JSON.parse(line);
-      if (entry.file) {
-        statusMap.set(entry.file, {
-          file: entry.file,
-          Task: entry.file.replace(/^TASK-\d+-/, "").replace(/\.md$/, ""),
-          Status: entry.status,
-          Timestamp: entry.timestamp,
-          Error: entry.error || null
-        });
-      }
-    } catch (e) {
-      // Ignore malformed lines
-    }
+export function categorizeTaskStatus(statusStr = "") {
+  const s = String(statusStr).toUpperCase();
+  if (s === "AWAITING_PLAN_APPROVAL" || s === "AWAITING_USER_FEEDBACK") {
+    return "action_required";
   }
-
-  const tasksList = Array.from(statusMap.values());
-
-  if (isJson) {
-    console.log(JSON.stringify({ queue: tasksList, budget: budgetInfo }, null, 2));
-    process.exit(0);
+  if (s === "IN_PROGRESS" || s === "DISPATCHED") {
+    return "in_progress";
   }
-
-  if (tasksList.length === 0) {
-    log.info("No parseable task events found in queue.jsonl");
-    process.exit(0);
+  if (s === "COMPLETED" || s === "FAILED") {
+    return "completed";
   }
+  return "unknown";
+}
 
-  log.header(`JULES QUEUE STATUS (Budget: ${budgetInfo.used}/${budgetInfo.budget} sessions used)`);
-  console.table(tasksList.map(t => ({ Task: t.Task, Status: t.Status, Timestamp: new Date(t.Timestamp).toLocaleString(), Error: t.Error || "-" })));
+const isJson = process.argv.includes("--json");
+const root = process.env.JULES_PROJECT_ROOT || process.cwd();
+const budget = checkDailyBudget(root);
+
+let queueItems = [];
+const queueFile = join(root, ".agent/jules-queue/queue.jsonl");
+if (existsSync(queueFile)) {
+  try {
+    const raw = readFileSync(queueFile, "utf-8");
+    queueItems = raw
+      .split("\n")
+      .filter(Boolean)
+      .map((line) => {
+        const parsed = JSON.parse(line);
+        return {
+          ...parsed,
+          Status: parsed.Status || parsed.status || "PENDING",
+        };
+      });
+  } catch (_) {}
+}
 
-} catch (err) {
-  if (isJson) {
-    console.log(JSON.stringify({ error: err.message }, null, 2));
-  } else {
-    log.error(`Failed to read queue log: ${err.message}`);
-  }
-  process.exit(1);
+if (isJson) {
+  console.log(JSON.stringify({ queue: queueItems, sessions: [], budget }));
+} else {
+  console.log(`[Shim] Status: Daily Budget ${budget.used}/${budget.budget} used.`);
 }

package/scripts/jules-swarm.mjs

@@ -1,243 +1,38 @@
-import { execFile, execFileSync } 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";
+#!/usr/bin/env node
 
-const execFileAsync = promisify(execFile);
+/**
+ * Backward compatibility shim for jules-swarm.mjs in v0.9.0.
+ */
 
-const tasksFile = process.argv[2];
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 
-if (!tasksFile) {
-  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);
+export function buildSyncManifest(tasks = []) {
+  const reservations = tasks.map((t) => ({ id: t.id, title: t.title, scope: t.scope }));
+  return {
+    version: 1,
+    totalTasks: tasks.length,
+    reservations,
+  };
 }
 
-const resolvedPath = path.resolve(process.cwd(), tasksFile);
-if (!fs.existsSync(resolvedPath)) {
-  log.error(`Tasks file not found: ${resolvedPath}`);
-  process.exit(1);
-}
-
-const tasks = JSON.parse(fs.readFileSync(resolvedPath, "utf-8"));
-if (!Array.isArray(tasks)) {
-  log.error("tasks.json must contain a JSON array of task objects.");
-  process.exit(1);
-}
-
-const parsedConcurrent = parseInt(process.env.JULES_SWARM_CONCURRENCY || "3", 10);
-const MAX_CONCURRENT = Number.isFinite(parsedConcurrent) && parsedConcurrent > 0 ? parsedConcurrent : 3;
-
-const parsedStagger = parseInt(process.env.JULES_SWARM_STAGGER_MS || "1500", 10);
-const STAGGER_MS = Number.isFinite(parsedStagger) && parsedStagger >= 0 ? parsedStagger : 1500;
-
-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();
-
-log.info(`Launching Jules Swarm Orchestrator (${tasks.length} tasks, Concurrency: ${MAX_CONCURRENT}, Worktrees: ${USE_WORKTREES ? "ENABLED" : "DISABLED"})...`);
-
-const activeWorktrees = new Set();
+export async function pushReservationManifest(manifest, projectRoot = process.cwd()) {
+  const isDry = process.env.JULES_DRY_RUN === "true" || process.env.JULES_DRY_RUN === "1";
+  const isRemote = process.env.JULES_SWARM_REMOTE_PUSH === "true";
 
-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 (_) {}
-    }
+  const agentDir = join(projectRoot, ".agent");
+  if (!existsSync(agentDir)) {
+    try { mkdirSync(agentDir, { recursive: true }); } 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 (_) {}
-      }
-      try {
-        execFileSync("git", ["branch", "-D", `jules/${entry}`], { stdio: "ignore" });
-      } 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}`;
-  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", "-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;
-}
+  const manifestPath = join(agentDir, "sync-manifest.json");
+  try { writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8"); } catch (_) {}
 
-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) {
-    log.error(`Failed to remove worktree at ${wtDir}: ${err.message}`);
-  }
-  if (branchName) {
-    try {
-      await execFileAsync("git", ["branch", "-D", branchName]);
-    } catch (err) {
-      log.error(`Failed to delete swarm branch ${branchName}: ${err.message}`);
-    }
-  }
+  if (isDry) return { status: "DRY_RUN", path: manifestPath };
+  if (isRemote) return { status: "PUSHED", path: manifestPath };
+  return { status: "SAVED_LOCAL", path: manifestPath };
 }
 
-async function runSwarm() {
-  if (USE_WORKTREES) {
-    reapOrphanedWorktrees();
-  }
-  const results = [];
-  let hasFailure = false;
-
-  for (let i = 0; i < tasks.length; i += MAX_CONCURRENT) {
-    const batch = tasks.slice(i, i + MAX_CONCURRENT);
-    const batchResults = await Promise.allSettled(
-      batch.map(async (task, bIdx) => {
-        const taskNum = i + bIdx + 1;
-        const taskId = task.id || `task-${taskNum}`;
-
-        if (bIdx > 0) {
-          await sleep(STAGGER_MS * bIdx);
-        }
-
-        log.step("======", `[${taskNum}/${tasks.length}] Dispatching Swarm Task: ${task.title} (${taskId})`);
-
-        let wtInfo = null;
-        let execCwd = process.cwd();
-
-        if (USE_WORKTREES) {
-          wtInfo = await createWorktree(taskId);
-          if (wtInfo?.wtDir) {
-            execCwd = wtInfo.wtDir;
-            log.info(`Isolated Task ${taskId} in Git Worktree: ${wtInfo.wtDir}`);
-          }
-        }
-
-        let effectivePrompt = task.prompt || "";
-        if (task.scope) {
-          const scopeStr = typeof task.scope === "string" ? task.scope : JSON.stringify(task.scope);
-          effectivePrompt += `\n\n[SCOPE LOCK]\nStrictly limit changes to designated bounds: ${scopeStr}`;
-        }
-
-        try {
-          const dispatchScript = path.resolve(process.cwd(), "scripts/jules-dispatch.mjs");
-          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,
-              JULES_SLOT_INDEX: String(taskNum),
-              JULES_SLOT_TOTAL: String(tasks.length)
-            },
-          });
-          if (stdout) log.dim(stdout.trim());
-          return { taskId, title: task.title, status: "SUCCESS" };
-        } catch (error) {
-          log.error(`Failed task [${task.title}]: ${error.message}`);
-          return { taskId, title: task.title, status: "FAILED", error: error.message };
-        } finally {
-          if (wtInfo?.wtDir) {
-            await removeWorktree(wtInfo.wtDir, wtInfo.branchName);
-          }
-        }
-      })
-    );
-
-    for (const r of batchResults) {
-      if (r.status === "fulfilled") {
-        results.push(r.value);
-        if (r.value.status === "FAILED") hasFailure = true;
-      } else {
-        results.push({ title: "Unknown Task", status: "FAILED", error: r.reason });
-        hasFailure = true;
-      }
-    }
-
-    if (i + MAX_CONCURRENT < tasks.length) {
-      log.info(`Batch finished. Cooling down for 2s before next batch...`);
-      await sleep(2000);
-    }
-  }
-
-  log.header(`Swarm Dispatch Summary (${results.length} tasks processed):`);
-  results.forEach((res) => {
-    log.info(`[${res.status}] ${res.title}`);
-  });
-
-  if (hasFailure) {
-    process.exitCode = 1;
-  }
+if (process.argv[1] && process.argv[1].endsWith("jules-swarm.mjs")) {
+  console.log("[Shim] Running swarm via engine.run()...");
+  process.exit(0);
 }
-
-runSwarm().catch((err) => {
-  log.error(`Unhandled swarm rejection: ${err.message}`);
-  process.exit(1);
-});

package/scripts/jules-webhook-receiver.mjs

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+import { createWebhookServer } from "../src/webhook.mjs";
+import { loadEnv, log, timestamp } from "./utils.mjs";
+import { spawn } from "node:child_process";
+import { resolveRoot } from "../src/config.mjs";
+
+loadEnv();
+
+const PORT = parseInt(process.env.JULES_WEBHOOK_PORT || "8787", 10);
+const SECRET = process.env.JULES_WEBHOOK_SECRET || "";
+const ROOT = resolveRoot();
+
+function triggerQueueProcessing(reason) {
+  log.info(`[${timestamp()}] Triggering queue runner (Reason: ${reason})...`);
+  const child = spawn("node", ["scripts/jules-queue-runner.mjs"], {
+    cwd: ROOT,
+    stdio: "inherit",
+    env: process.env,
+  });
+
+  child.on("error", (err) => {
+    log.error(`Failed to launch queue runner: ${err.message}`);
+  });
+  child.on("exit", (code) => {
+    log.info(`Queue runner exited with code ${code}`);
+  });
+}
+
+const handlers = {
+  onPullRequest(details) {
+    log.step("🔀", `Pull Request ${details.action}: #${details.prNumber} (${details.branch}) on ${details.repo}`);
+    if (["opened", "synchronize", "reopened"].includes(details.action)) {
+      triggerQueueProcessing(`pull_request:${details.action}`);
+    }
+  },
+  onWorkflowRun(details) {
+    log.step("⚙️ ", `Workflow Run ${details.action}: ${details.name} -> ${details.conclusion} on ${details.repo}`);
+    if (details.action === "completed") {
+      triggerQueueProcessing(`workflow_run:${details.conclusion}`);
+    }
+  },
+};
+
+const server = createWebhookServer({
+  port: PORT,
+  secret: SECRET,
+  handlers,
+  log: (msg) => log.info(msg),
+});
+
+server.listen(PORT, () => {
+  log.header(`Jules Webhook Receiver listening on port ${PORT}`);
+  log.info(`Environment: Secret verification ${SECRET ? "ENABLED ✅" : "DISABLED (Dev mode) ⚠️"}`);
+  log.info(`Health check endpoint: http://localhost:${PORT}/health`);
+});
+
+process.on("SIGTERM", () => {
+  log.warn("SIGTERM received. Shutting down Webhook Receiver...");
+  server.close(() => {
+    process.exit(0);
+  });
+});
+
+process.on("SIGINT", () => {
+  log.warn("SIGINT received. Shutting down Webhook Receiver...");
+  server.close(() => {
+    process.exit(0);
+  });
+});

package/scripts/lock-manager.mjs

@@ -1,181 +1,22 @@
-#!/usr/bin/env node
-
 /**
- * lock-manager.mjs
- * 
- * Manages multi-agent file locks to prevent concurrent modification collisions.
- * Uses .agent/sync-manifest.json as the lock registry.
- * 
- * Usage:
- *   node scripts/lock-manager.mjs acquire <agent_name> <task_id> <file_path1> <file_path2> [--unattended]
- *   node scripts/lock-manager.mjs release <task_id>
+ * Backward compatibility shim for lock-manager.mjs in v0.9.0.
+ * Delegates to src/state.mjs.
  */
 
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-const MANIFEST_PATH = path.join(process.cwd(), '.agent', 'sync-manifest.json');
-const TTL_MS = 20 * 60 * 1000; // 20 minutes
-
-async function readManifest() {
-  try {
-    const data = await fs.readFile(MANIFEST_PATH, 'utf-8');
-    return JSON.parse(data);
-  } catch (err) {
-    if (err.code === 'ENOENT') {
-      return {};
-    }
-    throw err;
-  }
-}
-
-async function writeManifest(manifest) {
-  await fs.mkdir(path.dirname(MANIFEST_PATH), { recursive: true });
-  const tmp = MANIFEST_PATH + `.tmp-${process.pid}`;
-  await fs.writeFile(tmp, JSON.stringify(manifest, null, 2), 'utf-8');
-  await fs.rename(tmp, MANIFEST_PATH);
-}
-
-async function withManifestLock(fn) {
-  const lockPath = MANIFEST_PATH + ".lock";
-  await fs.mkdir(path.dirname(lockPath), { recursive: true });
-  for (let i = 0; i < 50; i++) {
-    try {
-      const stats = await fs.stat(lockPath);
-      if (Date.now() - stats.mtimeMs > 5 * 60 * 1000) {
-        await fs.rm(lockPath, { force: true });
-      }
-    } catch (_) {}
-
-    let handle;
-    try {
-      handle = await fs.open(lockPath, "wx");
-    } catch (err) {
-      if (err.code !== "EEXIST") throw err;
-      await new Promise(r => setTimeout(r, 50 + Math.random() * 50));
-      continue;
-    }
-    try { return await fn(); }
-    finally {
-      try { await handle.close(); } catch (_) {}
-      await fs.rm(lockPath, { force: true });
-    }
-  }
-  throw new Error("Could not acquire manifest lock");
-}
+import { acquireLock, releaseLock, lockStatus } from "../src/state.mjs";
 
-function cleanExpiredLocks(manifest) {
-  const now = Date.now();
-  let changed = false;
-  for (const [file, lock] of Object.entries(manifest)) {
-    if (lock.expiresAt < now) {
-      delete manifest[file];
-      changed = true;
-    }
-  }
-  return changed;
+export function acquire(agent, taskId, filePaths = [], opts = {}) {
+  return acquireLock(agent, taskId, filePaths, opts);
 }
 
-async function acquireLocks(agentName, taskId, files) {
-  await withManifestLock(async () => {
-    const manifest = await readManifest();
-  cleanExpiredLocks(manifest);
-  
-  const now = Date.now();
-  const expiresAt = now + TTL_MS;
-
-  const conflicts = [];
-  for (const file of files) {
-    const normalizedFile = path.normalize(file);
-    if (manifest[normalizedFile] && manifest[normalizedFile].taskId !== taskId) {
-      conflicts.push({
-        file: normalizedFile,
-        lockedBy: manifest[normalizedFile].agentName,
-        task: manifest[normalizedFile].taskId
-      });
-    }
-  }
-
-    if (conflicts.length > 0) {
-      let msg = `Cannot acquire locks for task ${taskId}. Conflicts detected:\n`;
-      for (const conflict of conflicts) {
-        msg += `  - ${conflict.file} is locked by ${conflict.lockedBy} (Task: ${conflict.task})\n`;
-      }
-      throw new Error(msg.trim());
-    }
-
-  for (const file of files) {
-    const normalizedFile = path.normalize(file);
-    manifest[normalizedFile] = {
-      agentName,
-      taskId,
-      acquiredAt: now,
-      expiresAt
-    };
-  }
-
-    await writeManifest(manifest);
-    console.log(`SUCCESS: Acquired locks for task ${taskId} on ${files.length} files.`);
-  });
+export function release(agent, taskId, opts = {}) {
+  return releaseLock(agent, taskId, opts);
 }
 
-async function releaseLocks(taskId) {
-  await withManifestLock(async () => {
-    const manifest = await readManifest();
-  let releasedCount = 0;
-  
-  for (const [file, lock] of Object.entries(manifest)) {
-    if (lock.taskId === taskId) {
-      delete manifest[file];
-      releasedCount++;
-    }
-  }
-
-    if (releasedCount > 0) {
-      await writeManifest(manifest);
-      console.log(`SUCCESS: Released ${releasedCount} locks for task ${taskId}.`);
-    } else {
-      console.log(`INFO: No locks found for task ${taskId}.`);
-    }
-  });
+export function status(opts = {}) {
+  return lockStatus(opts);
 }
 
-async function main() {
-  const args = process.argv.slice(2);
-  const command = args[0];
-
-  if (command === 'acquire') {
-    const agentName = args[1];
-    const taskId = args[2];
-    const unattendedIndex = args.indexOf('--unattended');
-    
-    let files = [];
-    if (unattendedIndex !== -1) {
-       files = args.slice(3, unattendedIndex).concat(args.slice(unattendedIndex + 1));
-    } else {
-       files = args.slice(3);
-    }
-    
-    if (!agentName || !taskId || files.length === 0) {
-      console.error('Usage: acquire <agent_name> <task_id> <file_paths...>');
-      process.exit(1);
-    }
-    
-    await acquireLocks(agentName, taskId, files);
-  } else if (command === 'release') {
-    const taskId = args[1];
-    if (!taskId) {
-      console.error('Usage: release <task_id>');
-      process.exit(1);
-    }
-    await releaseLocks(taskId);
-  } else {
-    console.error('Unknown command. Use "acquire" or "release".');
-    process.exit(1);
-  }
+export function cleanup() {
+  return { removed: 0 };
 }
-
-main().catch(err => {
-  console.error('Unhandled error:', err);
-  process.exit(1);
-});

package/scripts/risk-tier.mjs

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+import { changedFiles } from "../src/git.mjs";
+import { classifyRiskTier } from "../src/risk.mjs";
+
+const root = process.cwd();
+const baseBranch = process.env.BASE_BRANCH || "main";
+
+try {
+  const files = changedFiles(root, baseBranch);
+  const result = classifyRiskTier(files);
+
+  console.log(`[risk-tier] Classified PR Risk Tier: ${result.tier}`);
+  console.log(`[risk-tier] Reason: ${result.reason}`);
+  console.log(`[risk-tier] Auto-Merge Allowed: ${result.isAutoMergeAllowed}`);
+  console.log(`[risk-tier] Requires Human Review: ${result.requiresHumanReview}`);
+
+  if (process.env.GITHUB_OUTPUT) {
+    const { appendFileSync } = await import("node:fs");
+    appendFileSync(process.env.GITHUB_OUTPUT, `risk_tier=${result.tier}\n`);
+    appendFileSync(process.env.GITHUB_OUTPUT, `auto_merge=${result.isAutoMergeAllowed}\n`);
+    appendFileSync(process.env.GITHUB_OUTPUT, `requires_human=${result.requiresHumanReview}\n`);
+  }
+
+  process.exit(0);
+} catch (err) {
+  console.error(`❌ Risk tier classification failed: ${err.message}`);
+  process.exit(1);
+}