jules-orchestrator-kit 0.23.0 → 1.0.0

package/scripts/utils.mjs

@@ -159,3 +159,68 @@ export function acquireBudgetLock(_root) {
 }
 
 export function releaseBudgetLock(_root) {}
+
+export function extractPrUrls(outputs = []) {
+  const prs = [];
+  const regex = /https:\/\/github\.com\/[^\s/]+\/[^\s/]+\/pull\/\d+/g;
+  for (const item of outputs) {
+    const text = typeof item === "string" ? item : item?.link || JSON.stringify(item);
+    const matches = text.match(regex);
+    if (matches) {
+      for (const m of matches) {
+        if (!prs.includes(m)) prs.push(m);
+      }
+    }
+  }
+  return prs;
+}
+
+export function auditSessions(sessions = [], opts = {}) {
+  const staleHoursThreshold = opts.staleHoursThreshold || 24;
+  const now = Date.now();
+  const merged = [];
+  const active = [];
+  const stale = [];
+
+  for (const s of sessions) {
+    if (s.state === "MERGED") {
+      merged.push(s);
+    } else {
+      const updatedMs = s.updateTime ? new Date(s.updateTime).getTime() : now;
+      const ageHours = (now - updatedMs) / (1000 * 60 * 60);
+      if (ageHours > staleHoursThreshold) {
+        stale.push(s);
+      } else {
+        active.push(s);
+      }
+    }
+  }
+
+  return { merged, active, stale };
+}
+
+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,
+  };
+}
+
+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";
+
+  const agentDir = join(projectRoot, ".agent");
+  if (!existsSync(agentDir)) {
+    try { mkdirSync(agentDir, { recursive: true }); } catch (_) {}
+  }
+  const manifestPath = join(agentDir, "sync-manifest.json");
+  try { writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8"); } catch (_) {}
+
+  if (isDry) return { status: "DRY_RUN", path: manifestPath };
+  if (isRemote) return { status: "PUSHED", path: manifestPath };
+  return { status: "SAVED_LOCAL", path: manifestPath };
+}
+

package/src/engine.mjs

@@ -354,6 +354,16 @@ export async function repair(failure, opts = {}) {
     attempts.push({ n, session, ok: true });
     appendTelemetry(root, "ooda_repair_attempt", { attempt: n, ok: true });
 
+    // Poll async provider for terminal session state before executing re-verification gates
+    if (provider && session) {
+      await pollSessionState(provider, session, {
+        root,
+        dryRun: opts.dryRun,
+        pollIntervalMs: opts.pollIntervalMs,
+        maxPollAttempts: opts.maxPollAttempts,
+      });
+    }
+
     // Re-verify after repair attempt
     const gateRes = await gate({ root, config, fix: false, progressBus, progressToken });
     if (gateRes.ok) {
@@ -379,6 +389,50 @@ export async function repair(failure, opts = {}) {
   return { ok: false, attempts, finalStatus: "OODA_EXHAUSTED" };
 }
 
+/**
+ * Polls an async provider for terminal session state (COMPLETED / FAILED) before re-verification.
+ */
+export async function pollSessionState(provider, session, opts = {}) {
+  if (!session || !session.id) return { status: "COMPLETED" };
+  const initialStatus = String(session.status || session.state || "").toUpperCase();
+  if (initialStatus === "COMPLETED" || initialStatus === "FAILED" || opts.dryRun || session.id === "dry-run-session-id") {
+    return { status: initialStatus || "COMPLETED" };
+  }
+
+  const maxAttempts = opts.maxPollAttempts || 30;
+  const pollIntervalMs = opts.pollIntervalMs || 1000;
+  const timeoutMs = opts.pollTimeoutMs || 300000;
+  const startTime = Date.now();
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (Date.now() - startTime > timeoutMs) break;
+
+    let currentSession = null;
+    if (provider && typeof provider.getSession === "function") {
+      try {
+        currentSession = await provider.getSession(session.id, opts);
+      } catch (_) {}
+    } else if (typeof opts.pollFn === "function") {
+      try {
+        currentSession = await opts.pollFn(session.id);
+      } catch (_) {}
+    }
+
+    if (currentSession) {
+      const status = String(currentSession.status || currentSession.state || "").toUpperCase();
+      if (status === "COMPLETED" || status === "FAILED") {
+        return { ...currentSession, status };
+      }
+    } else {
+      break;
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+  }
+
+  return { ...session, status: String(session.status || "COMPLETED").toUpperCase() };
+}
+
 function buildRepairPrompt(failure, attempt, _config) {
   const cleanStderr = redactSecrets(failure.stderr || failure.stdout || "Unknown Error");
 
@@ -435,32 +489,54 @@ export async function dispatch(task, opts = {}) {
   );
 }
 
-export async function run(opts = {}) {
-  const root = opts.root || process.cwd();
-  const config = opts.config || loadConfig(root);
-  const concurrency = opts.concurrency || config.limits.concurrency || 1;
+export async function run(tasksOrOpts = {}, opts = {}) {
+  let tasks = null;
+  let options = opts;
+  if (Array.isArray(tasksOrOpts)) {
+    tasks = tasksOrOpts;
+    options = opts || {};
+  } else if (tasksOrOpts && typeof tasksOrOpts === "object") {
+    options = tasksOrOpts;
+  }
+
+  const root = options.root || process.cwd();
+  const config = options.config || loadConfig(root);
+  const concurrency = options.concurrency || config.limits.concurrency || 1;
+  const isDry = options.dryRun !== undefined ? options.dryRun : (process.env.JULES_DRY_RUN === "true" || process.env.JULES_DRY_RUN === "1");
   const queueDir = getQueueDir(root);
   const completedDir = join(queueDir, "completed");
   ensureDir(completedDir);
 
-  const files = readdirSync(queueDir).filter((f) => isTaskFile(f, queueDir));
+  let filesToProcess = [];
+  if (Array.isArray(tasks)) {
+    filesToProcess = tasks.map((t) => (typeof t === "string" ? t : t.id || t.file || t.title));
+  } else {
+    filesToProcess = readdirSync(queueDir).filter((f) => isTaskFile(f, queueDir));
+  }
+
   const results = [];
 
-  for (let i = 0; i < files.length; i += concurrency) {
-    const batch = files.slice(i, i + concurrency);
+  for (let i = 0; i < filesToProcess.length; i += concurrency) {
+    const batch = filesToProcess.slice(i, i + concurrency);
     await Promise.all(
-      batch.map(async (file) => {
-        const srcPath = join(queueDir, file);
+      batch.map(async (fileOrItem) => {
+        const fileName = typeof fileOrItem === "string" ? fileOrItem : fileOrItem.id || fileOrItem.file;
+        const srcPath = join(queueDir, fileName);
         try {
-          const content = readFileSync(srcPath, "utf-8");
-          const task = { title: file, prompt: content };
-          const session = await dispatch(task, { root, config, dryRun: opts.dryRun });
-          const dstPath = join(completedDir, file);
-          renameSync(srcPath, dstPath);
-          appendLedger({ event: "task_completed", file, session }, root);
-          results.push({ file, ok: true, session });
+          let prompt = typeof fileOrItem === "object" && fileOrItem.prompt ? fileOrItem.prompt : "";
+          if (!prompt && existsSync(srcPath)) {
+            prompt = readFileSync(srcPath, "utf-8");
+          }
+          const task = { title: fileName, prompt };
+          const session = await dispatch(task, { root, config, dryRun: isDry });
+          const dstPath = join(completedDir, fileName);
+          if (existsSync(srcPath)) {
+            renameSync(srcPath, dstPath);
+          }
+          appendLedger({ event: "task_completed", file: fileName, session }, root);
+          results.push({ file: fileName, ok: true, session });
         } catch (err) {
-          results.push({ file, ok: false, error: err.message });
+          results.push({ file: fileName, ok: false, error: err.message });
         }
       })
     );

package/src/envelope.mjs

@@ -1,4 +1,4 @@
-import { git, resolveBase } from "./git.mjs";
+import { git, runCmd, resolveBase } from "./git.mjs";
 import { checkScope } from "./security.mjs";
 import { normalizeScope } from "./config.mjs";
 import { existsSync } from "node:fs";
@@ -70,8 +70,8 @@ export function validateEnvelope(envelope = {}, opts = {}) {
       const absPath = join(root, relPath);
       let existsInGit = false;
       if (resolvedBase) {
-        const catRes = git(["cat-file", "-e", `${resolvedBase}:${relPath}`], { cwd: root, ignoreError: true });
-        existsInGit = typeof catRes === "string" && catRes.trim() !== "";
+        const catRes = runCmd(["git", "cat-file", "-e", `${resolvedBase}:${relPath}`], { cwd: root, ignoreError: true });
+        existsInGit = catRes.status === 0;
       }
       const existsOnDisk = existsSync(absPath);
       if (!existsInGit && !existsOnDisk) {

package/src/flaky-ledger.mjs

@@ -83,8 +83,6 @@ export function readVerifyRuns(root, testCmd = null) {
   }
 }
 
-export const getVerifyRuns = readVerifyRuns;
-
 /**
  * Evaluates flaky test verdict using a sliding window of the last n <= 10 runs.
  */

package/src/git.mjs

@@ -1,5 +1,5 @@
 import { execFileSync } from "node:child_process";
-import { sep } from "node:path";
+import { normalizePath } from "./config.mjs";
 import { journalIntent, journalDone } from "./journal.mjs";
 
 export const NET_GUARD_PRELOAD_URL = new URL("./preload-net-guard.mjs", import.meta.url).href;
@@ -13,11 +13,6 @@ export class GateError extends Error {
   }
 }
 
-function normalizePath(p) {
-  if (!p || typeof p !== "string") return "";
-  return p.split(sep).join("/").replace(/\\/g, "/");
-}
-
 const DEFAULT_TIMEOUT = 10 * 60 * 1000; // 10 minutes
 const DEFAULT_MAX_BUFFER = 10 * 1024 * 1024; // 10 MB
 

package/src/mcp.mjs

@@ -9,7 +9,7 @@ import { ProgressBus } from "./mcp-progress.mjs";
 
 export const MCP_SERVER_INFO = {
   name: "jules-orchestrator-kit",
-  version: "0.23.0",
+  version: "1.0.0",
 };
 
 export const MAX_MCP_FRAME_SIZE = 4 * 1024 * 1024; // 4 MB memory safety ceiling

package/src/merge-verify.mjs

@@ -31,14 +31,14 @@ export function mergeVerifyChain(mergedText, fileName, root = process.cwd()) {
       tool = "python3 -m py_compile";
     } else if (ext === ".ts" || ext === ".tsx" || ext === ".mts" || ext === ".cts") {
       const hasTsConfig = existsSync(join(root, "tsconfig.json"));
-      if (hasTsConfig) {
-        cmd = "npx";
-        args = ["tsc", "--noEmit", tempFilePath];
+      const localTsc = join(root, "node_modules", ".bin", "tsc");
+      const hasLocalTsc = existsSync(localTsc);
+      if (hasTsConfig && hasLocalTsc) {
+        cmd = localTsc;
+        args = ["--noEmit", tempFilePath];
         tool = "tsc --noEmit";
       } else {
-        cmd = "node";
-        args = ["--check", tempFilePath];
-        tool = "node --check";
+        return { ok: true, tool: "ts-skipped-no-tsconfig" };
       }
     } else {
       // JS, MJS, CJS or default
@@ -47,7 +47,7 @@ export function mergeVerifyChain(mergedText, fileName, root = process.cwd()) {
       tool = "node --check";
     }
 
-    const res = spawnSync(cmd, args, { encoding: "utf8" });
+    const res = spawnSync(cmd, args, { encoding: "utf8", timeout: 120000 });
     const ok = res.status === 0;
 
     return {

package/src/state.mjs

@@ -349,8 +349,9 @@ export function isPidAlive(pid, expectedStartTime = null) {
   return true;
 }
 
-export function acquireLock(agentName, taskId, files = [], rootOrOpts = resolveRoot()) {
-  const root = typeof rootOrOpts === "string" ? rootOrOpts : resolveRoot();
+export function acquireLock(agentName, taskId, files = [], rootOrOpts = resolveRoot(), opts = {}) {
+  const root = typeof rootOrOpts === "string" ? rootOrOpts : (rootOrOpts?.root || resolveRoot());
+  const branch = (typeof rootOrOpts === "object" && rootOrOpts?.branch) || opts?.branch || process.env.JULES_BRANCH || process.env.BRANCH_NAME || "";
   const lockDir = getLockDir(root);
   const lockFile = join(lockDir, `${taskId}.json`);
 
@@ -375,6 +376,7 @@ export function acquireLock(agentName, taskId, files = [], rootOrOpts = resolveR
   const payload = {
     agent: agentName,
     taskId,
+    branch,
     files,
     pid: process.pid,
     processStartTime: startTime,

package/src/telemetry.mjs

@@ -1,6 +1,7 @@
 import {
   openSync,
   writeSync,
+  readSync,
   closeSync,
   readFileSync,
   existsSync,
@@ -16,6 +17,37 @@ import { safeAtomicWrite } from "./security.mjs";
 export const MAX_TELEMETRY_SEGMENT_BYTES = 8 * 1024 * 1024; // 8 MB log segment ceiling
 export const TELEMETRY_GENESIS_HASH = "0".repeat(64);
 
+/**
+ * Reads up to 64 KB from EOF of target log segment to extract true tail hash.
+ */
+function readTailHash(filePath, bufferSize = 64 * 1024) {
+  if (!existsSync(filePath)) return null;
+  try {
+    const stat = statSync(filePath);
+    if (stat.size === 0) return null;
+    const readSize = Math.min(stat.size, bufferSize);
+    const position = stat.size - readSize;
+    const fd = openSync(filePath, "r");
+    const buf = Buffer.alloc(readSize);
+    try {
+      readSync(fd, buf, 0, readSize, position);
+    } finally {
+      closeSync(fd);
+    }
+    const content = buf.toString("utf-8");
+    const lines = content.split("\n").filter(Boolean);
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const obj = JSON.parse(lines[i]);
+        if (obj && typeof obj.hash === "string") {
+          return obj.hash;
+        }
+      } catch (_) {}
+    }
+  } catch (_) {}
+  return null;
+}
+
 /**
  * Returns telemetry file paths for a given date string sorted by segment index.
  */
@@ -50,18 +82,10 @@ function coldScanTelemetry(stateDir, dateStr) {
   for (let i = segments.length - 1; i >= 0; i--) {
     const seg = segments[i];
     if (existsSync(seg.path)) {
-      try {
-        const content = readFileSync(seg.path, "utf-8");
-        const lines = content.split("\n").filter(Boolean);
-        for (let j = lines.length - 1; j >= 0; j--) {
-          try {
-            const entry = JSON.parse(lines[j]);
-            if (entry && typeof entry.hash === "string") {
-              return { hash: entry.hash, segment: seg.index };
-            }
-          } catch (_) {}
-        }
-      } catch (_) {}
+      const tailHash = readTailHash(seg.path);
+      if (tailHash) {
+        return { hash: tailHash, segment: seg.index };
+      }
     }
   }
 
@@ -70,7 +94,7 @@ function coldScanTelemetry(stateDir, dateStr) {
 
 /**
  * Appends a structured telemetry event to .agent/state/telemetry-<date>.jsonl with SHA-256 hash chaining.
- * Uses .head atomic cache for O(1) constant-time appends.
+ * Uses .head atomic cache with true tail reconciliation for O(1) constant-time appends.
  *
  * @param {string} [rootOrOpts]
  * @param {string} kind
@@ -102,18 +126,30 @@ export function appendTelemetry(rootOrOpts = resolveRoot(), kind = "event", fiel
       } catch (_) {}
     }
 
-    if (!headValid) {
-      const recovered = coldScanTelemetry(stateDir, dateStr);
-      prevHash = recovered.hash;
-      activeSegmentIndex = recovered.segment;
-    }
-
     let activeFileName =
       activeSegmentIndex === 0
         ? `telemetry-${dateStr}.jsonl`
         : `telemetry-${dateStr}-${activeSegmentIndex}.jsonl`;
     let activeFilePath = join(stateDir, activeFileName);
 
+    // Reconcile .head hash against true log tail (reading last 64 KB from EOF)
+    const tailHash = readTailHash(activeFilePath);
+    if (tailHash) {
+      if (tailHash !== prevHash) {
+        prevHash = tailHash;
+      }
+      headValid = true;
+    } else if (!headValid) {
+      const recovered = coldScanTelemetry(stateDir, dateStr);
+      prevHash = recovered.hash;
+      activeSegmentIndex = recovered.segment;
+      activeFileName =
+        activeSegmentIndex === 0
+          ? `telemetry-${dateStr}.jsonl`
+          : `telemetry-${dateStr}-${activeSegmentIndex}.jsonl`;
+      activeFilePath = join(stateDir, activeFileName);
+    }
+
     if (existsSync(activeFilePath)) {
       try {
         const stat = statSync(activeFilePath);

package/.agent/jules-queue/README.md

@@ -1,30 +0,0 @@
-# Jules Task Queue Directory
-
-Drop markdown task specification files here (e.g. `TASK-001-feature-name.md`) to queue tasks for background execution by Google Jules.
-
-### File Format Example
-
-```markdown
-# TASK-001: Implement User Rate Limiting
-
-## Objective
-Implement sliding window rate limiting for public API routes.
-
-## Execution Rules
-- Use Redis / memory store for tracking hit counts.
-- Must return HTTP 429 Too Many Requests when limit is exceeded.
-- Must pass `npm test` before submitting PR.
-```
-
-Process all queued tasks in batch:
-
-```bash
-agentctl queue
-# or npm run jules:queue
-```
-
-Or dispatch a single task using `agentctl dispatch`:
-
-```bash
-agentctl dispatch --title "TASK-001 Rate Limiting" --prompt "$(cat .agent/jules-queue/TASK-001-rate-limiting.md)"
-```

package/.agent/jules.yml

@@ -1,13 +0,0 @@
-# Google Jules Repository Configuration (Version 2)
-version: 2
-test_cmd: "npm test"
-build_cmd: ""
-forbidden_paths:
-  - ".github/**"
-  - "**/secrets/**"
-  - "**/*.pem"
-  - "**/lock-manager/**"
-  - "scripts/jules-self-audit.mjs"
-  - ".agent/jules.yml"
-allow_paths: []
-

package/.env.example

@@ -1,73 +0,0 @@
-# Google Jules Orchestration Kit - Environment Configuration Example
-# Copy this file to .env and populate with your credentials/settings.
-
-# --- Authentication & Core Settings ---
-# Google Jules API Key (Required for direct REST API dispatches)
-JULES_API_KEY=your_google_jules_api_key_here
-
-# Alias for API key (fallback if JULES_API_KEY is not set)
-# GEMINI_API_KEY=your_gemini_api_key_here
-
-# Override the Jules REST API URL
-# JULES_API_URL=https://jules.googleapis.com/v1alpha/sessions
-
-# Target GitHub Repository (Format: owner/repo)
-JULES_REPO=owner/repo
-
-# Set to "true" or "1" to run in repoless/serverless mode
-# JULES_REPOLESS=false
-
-# Enable Dry-Run mode to simulate payload dispatch without making API calls
-# JULES_DRY_RUN=false
-
-# --- Budget & Security Gatekeeper ---
-# Daily max session limit for autonomous dispatches (Default: 300)
-# JULES_DAILY_BUDGET=300
-
-# Allow modifications to command-defining files (package.json, Cargo.toml, etc.) in PRs (Default: false)
-# JULES_ALLOW_COMMAND_FILE_CHANGES=false
-
-# Allow modifications to agent rule files (AGENTS.md, JULES_RULES_TEMPLATE.md, .agent/rules/**) in PRs (Default: false)
-# JULES_ALLOW_AGENT_RULE_CHANGES=false
-
-# --- Execution Scope & Git ---
-# Base Branch for PR Audits & Merge-Base Calculations (Default: main)
-BASE_BRANCH=main
-
-# PR Head Branch (Used by CI to dynamically target branches during OODA repair)
-# GITHUB_HEAD_REF=my-feature-branch
-
-# Root directory of the project (Auto-assigned during swarm executions)
-# JULES_PROJECT_ROOT=/path/to/project
-
-# --- Swarm & Concurrency ---
-# Maximum parallel dispatches for swarm runs (Default: 3)
-JULES_SWARM_CONCURRENCY=3
-
-# Dispatch Stagger Interval in Milliseconds (Default: 1500)
-JULES_SWARM_STAGGER_MS=1500
-
-# Rate-limit for the jules:queue command (Default: 500)
-# JULES_PACE_MS=500
-
-# Use Git Worktrees instead of cloning for swarm isolation
-# JULES_USE_WORKTREES=false
-
-# Current slot index for partitioning tasks (Swarm mode)
-# JULES_SLOT_INDEX=1
-
-# Total number of slots for partitioning tasks (Swarm mode)
-# JULES_SLOT_TOTAL=3
-
-# --- CI & Output ---
-# Is this running in a CI environment? (Changes log output and fail-fast behaviors)
-# CI=true
-
-# Allow OODA Auto-Repair even in CI environments
-# ALLOW_AUTO_REPAIR=true
-
-# GitHub Actions Step Summary File Path
-# GITHUB_STEP_SUMMARY=/path/to/step_summary.md
-
-# Disable color in terminal output
-# NO_COLOR=true

package/.github/workflows/jules-audit.yml

@@ -1,49 +0,0 @@
-name: Jules PR Audit & Test Gatekeeper
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  audit-and-test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        node-version: ['20.x', '22.x', '24.x']
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: ${{ matrix.node-version }}
-
-      - name: Cache OODA state & ledgers
-        uses: actions/cache@v4
-        with:
-          path: .agent/state/
-          key: ooda-state-${{ runner.os }}-${{ github.run_id }}
-          restore-keys: |
-            ooda-state-${{ runner.os }}-
-
-      - name: Install dependencies
-        run: npm install
-
-      - name: Run Linter
-        run: npm run lint --if-present
-
-      - name: Run Unit Tests
-        run: npm test --if-present
-
-      - name: Run Jules PR Self-Audit Gatekeeper
-        if: matrix.node-version == '22.x' && github.event_name == 'pull_request'
-        run: node scripts/jules-self-audit.mjs
-        env:
-          CI: "true"
-          BASE_BRANCH: "main"
-

package/scripts/jules-cleanup.mjs

@@ -1,49 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Backward compatibility shim for jules-cleanup.mjs in v0.9.0.
- */
-
-export function extractPrUrls(outputs = []) {
-  const prs = [];
-  const regex = /https:\/\/github\.com\/[^\s/]+\/[^\s/]+\/pull\/\d+/g;
-  for (const item of outputs) {
-    const text = typeof item === "string" ? item : item?.link || JSON.stringify(item);
-    const matches = text.match(regex);
-    if (matches) {
-      for (const m of matches) {
-        if (!prs.includes(m)) prs.push(m);
-      }
-    }
-  }
-  return prs;
-}
-
-export function auditSessions(sessions = [], opts = {}) {
-  const staleHoursThreshold = opts.staleHoursThreshold || 24;
-  const now = Date.now();
-  const merged = [];
-  const active = [];
-  const stale = [];
-
-  for (const s of sessions) {
-    if (s.state === "MERGED") {
-      merged.push(s);
-    } else {
-      const updatedMs = s.updateTime ? new Date(s.updateTime).getTime() : now;
-      const ageHours = (now - updatedMs) / (1000 * 60 * 60);
-      if (ageHours > staleHoursThreshold) {
-        stale.push(s);
-      } else {
-        active.push(s);
-      }
-    }
-  }
-
-  return { merged, active, stale };
-}
-
-if (process.argv[1] && process.argv[1].endsWith("jules-cleanup.mjs")) {
-  console.log("[Shim] Cleanup audit completed.");
-  process.exit(0);
-}