jules-orchestrator-kit 0.23.0 → 0.24.0

package/bin/agentctl.mjs

@@ -14,7 +14,7 @@ const command = args[0];
 
 function printHelp() {
   console.log(`
-🚀 agentctl v0.23.0 — Universal Agent Orchestrator & Safety Gatekeeper
+🚀 agentctl v0.24.0 — Universal Agent Orchestrator & Safety Gatekeeper
 
 Usage: agentctl <command> [options]
 
@@ -44,7 +44,7 @@ async function main() {
   }
 
   if (command === "version" || command === "--version" || command === "-v") {
-    console.log("agentctl v0.22.9");
+    console.log("agentctl v0.24.0");
     process.exit(0);
   }
 
@@ -226,7 +226,7 @@ async function main() {
     }
 
     case "doctor": {
-      console.log(`\n🔍 agentctl System Diagnostics (v0.22.9)`);
+      console.log(`\n🔍 agentctl System Diagnostics (v0.24.0)`);
       console.log(`--------------------------------------------------`);
       console.log(`  Project Root     : ${root}`);
       console.log(`  Config File      : ${config._file || "None (Using defaults)"}`);

package/bin/init.js

@@ -248,13 +248,12 @@ if (fs.existsSync(targetPkgPath) && targetDir !== kitRoot) {
     let updated = false;
     const julesScripts = {
       "jules:dispatch": "node scripts/jules-dispatch.mjs",
-      "jules:queue": "node scripts/jules-queue-runner.mjs",
+      "jules:queue": "node bin/agentctl.mjs queue",
       "jules:create": "node scripts/jules-create.mjs",
       "jules:status": "node scripts/jules-status.mjs",
       "jules:audit": "node scripts/jules-self-audit.mjs",
-      "jules:cleanup": "node scripts/jules-cleanup.mjs",
       "jules:scan": "node scripts/jules-scan-todos.mjs",
-      "jules:swarm": "node scripts/jules-swarm.mjs",
+      "jules:swarm": "node bin/agentctl.mjs swarm",
       "jules:nightly": "node scripts/jules-nightly.mjs"
     };
 

package/index.mjs

@@ -1,5 +1,5 @@
 /**
- * Google Jules Orchestrator Kit - Node.js SDK (v0.9.0)
+ * Google Jules Orchestrator Kit - Node.js SDK (v0.24.0)
  *
  * Exposes core orchestrator functions for programmatically driving agent tasks,
  * security auditing, repo gating, and state operations.
@@ -58,3 +58,5 @@ export { runSelfAudit, runPreflightSandbox } from "./scripts/jules-self-audit.mj
 export { scanCodebaseForTodos, runScanner } from "./scripts/jules-scan-todos.mjs";
 export { getDynamicGuardrails, dispatchTask } from "./scripts/jules-dispatch.mjs";
 export { classifyQueueFailure } from "./scripts/jules-queue-runner.mjs";
+export { extractPrUrls, auditSessions, buildSyncManifest, pushReservationManifest } from "./scripts/utils.mjs";
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jules-orchestrator-kit",
-  "version": "0.23.0",
+  "version": "0.24.0",
   "description": "Orchestration kit for running Google Jules autonomous agents.",
   "repository": {
     "type": "git",
@@ -42,13 +42,12 @@
     "init": "node bin/init.js",
     "test": "node --test test/*.test.mjs",
     "jules:dispatch": "node scripts/jules-dispatch.mjs",
-    "jules:queue": "node scripts/jules-queue-runner.mjs",
+    "jules:queue": "node bin/agentctl.mjs queue",
     "jules:create": "node scripts/jules-create.mjs",
     "jules:status": "node scripts/jules-status.mjs",
     "jules:audit": "node scripts/jules-self-audit.mjs",
-    "jules:cleanup": "node scripts/jules-cleanup.mjs",
     "jules:scan": "node scripts/jules-scan-todos.mjs",
-    "jules:swarm": "node scripts/jules-swarm.mjs",
+    "jules:swarm": "node bin/agentctl.mjs swarm",
     "jules:merge-swarm": "node scripts/jules-merge-swarm.mjs",
     "jules:patch": "node scripts/jules-patch.mjs",
     "jules:nightly": "node scripts/jules-nightly.mjs",

package/scripts/jules-queue-runner.mjs

@@ -4,10 +4,7 @@
  * Backward compatibility shim for jules-queue-runner.mjs in v0.9.0.
  */
 
-import { getQueueDir, ensureDir } from "../src/state.mjs";
-import { isTaskFile } from "../src/engine.mjs";
-import { readdirSync, renameSync } from "node:fs";
-import { join } from "node:path";
+import { run } from "../src/engine.mjs";
 
 export function classifyQueueFailure(err) {
   const msg = String(err?.message || err || "");
@@ -19,25 +16,9 @@ export function classifyQueueFailure(err) {
 
 if (process.argv[1] && process.argv[1].endsWith("jules-queue-runner.mjs")) {
   const root = process.env.JULES_PROJECT_ROOT || process.cwd();
-  const queueDir = getQueueDir(root);
-  const files = readdirSync(queueDir).filter((f) => isTaskFile(f, queueDir));
-
-  if (files.length === 0) {
-    console.log("Queue processing complete!");
-    process.exit(0);
-  }
-
-  const completedDir = join(queueDir, "completed");
-  ensureDir(completedDir);
-
-  for (const file of files) {
-    const src = join(queueDir, file);
-    const dst = join(completedDir, file);
-    try {
-      renameSync(src, dst);
-    } catch (_) {}
-  }
+  const isDry = process.env.JULES_DRY_RUN === "true" || process.env.JULES_DRY_RUN === "1";
 
+  await run({ root, dryRun: isDry });
   console.log("Queue processing complete!");
   process.exit(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/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/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);
-}

package/scripts/jules-swarm.mjs

@@ -1,38 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Backward compatibility shim for jules-swarm.mjs in v0.9.0.
- */
-
-import { existsSync, mkdirSync, writeFileSync } from "node:fs";
-import { join } from "node:path";
-
-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 };
-}
-
-if (process.argv[1] && process.argv[1].endsWith("jules-swarm.mjs")) {
-  console.log("[Shim] Running swarm via engine.run()...");
-  process.exit(0);
-}

package/scripts/lock-manager.mjs

@@ -1,22 +0,0 @@
-/**
- * Backward compatibility shim for lock-manager.mjs in v0.9.0.
- * Delegates to src/state.mjs.
- */
-
-import { acquireLock, releaseLock, lockStatus } from "../src/state.mjs";
-
-export function acquire(agent, taskId, filePaths = [], opts = {}) {
-  return acquireLock(agent, taskId, filePaths, opts);
-}
-
-export function release(agent, taskId, opts = {}) {
-  return releaseLock(agent, taskId, opts);
-}
-
-export function status(opts = {}) {
-  return lockStatus(opts);
-}
-
-export function cleanup() {
-  return { removed: 0 };
-}