jules-orchestrator-kit 0.22.9 → 0.24.0

package/bin/agentctl.mjs

@@ -14,7 +14,7 @@ const command = args[0];
 
 function printHelp() {
   console.log(`
-🚀 agentctl v0.22.9 — 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.22.9",
+  "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/dag-engine.mjs

@@ -1,5 +1,6 @@
 import { createHash } from "node:crypto";
 import { readFileSync, existsSync } from "node:fs";
+import { appendTelemetry } from "./telemetry.mjs";
 
 /**
  * Custom error thrown when a circular dependency is detected in the DAG.
@@ -200,8 +201,17 @@ export class DagExecutor {
    * @param {Object} [options]
    * @param {number} [options.concurrency]
    * @param {number} [options.taskTimeout]
+   * @param {string} [options.root]
+   * @param {Object} [options.progressBus]
+   * @param {string} [options.progressToken]
    */
-  async execute({ concurrency = this.concurrency, taskTimeout = this.taskTimeout } = {}) {
+  async execute({
+    concurrency = this.concurrency,
+    taskTimeout = this.taskTimeout,
+    root,
+    progressBus,
+    progressToken,
+  } = {}) {
     this.isExecuting = true;
     const { dependents } = this.validateDag();
 
@@ -265,6 +275,7 @@ export class DagExecutor {
           }
 
           running.add(taskId);
+          if (root) appendTelemetry(root, "dag_task_started", { taskId });
 
           (async () => {
             try {
@@ -291,6 +302,17 @@ export class DagExecutor {
               running.delete(taskId);
               completed.add(taskId);
 
+              if (root) appendTelemetry(root, "dag_task_completed", { taskId });
+              if (progressBus && progressToken) {
+                const pct = Math.round((completed.size / this.tasks.size) * 100);
+                progressBus.reportProgress(
+                  progressToken,
+                  pct,
+                  100,
+                  `Task ${taskId} completed (${completed.size}/${this.tasks.size})`
+                );
+              }
+
               for (const depNode of dependents.get(taskId)) {
                 inDegree.set(depNode, inDegree.get(depNode) - 1);
               }

package/src/engine.mjs

@@ -8,6 +8,7 @@ import { recordVerifyRun, readVerifyRuns, flakyVerdict } from "./flaky-ledger.mj
 import { readdirSync, readFileSync, renameSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { createHash } from "node:crypto";
+import { appendTelemetry } from "./telemetry.mjs";
 
 export { recordVerifyRun, readVerifyRuns, flakyVerdict, sanitizeUntrustedData };
 
@@ -100,8 +101,12 @@ export async function gate(opts = {}) {
   const root = opts.root || process.cwd();
   const config = opts.config || loadConfig(root);
   const base = opts.base || config.baseBranch || "main";
+  const progressBus = opts.progressBus;
+  const progressToken = opts.progressToken;
   const phases = [];
 
+  appendTelemetry(root, "gate_started", { base });
+
   let files = [];
   let bytes = 0;
   let diffStr = "";
@@ -112,6 +117,7 @@ export async function gate(opts = {}) {
     diffStr = diffText(root, base);
   } catch (err) {
     phases.push({ phase: "git_resolution", ok: false, error: err.message });
+    appendTelemetry(root, "gate_finished", { ok: false, code: 1, error: err.message });
     return { ok: false, code: 1, phases, error: err.message };
   }
 
@@ -142,7 +148,13 @@ export async function gate(opts = {}) {
   });
 
   phases.push({ phase: "scope", ok: scopeResult.ok, violations: scopeResult.violations });
+  appendTelemetry(root, "gate_phase", { phase: "scope", ok: scopeResult.ok });
+  if (progressBus && progressToken) {
+    progressBus.reportProgress(progressToken, 25, 100, "Phase 1/4: Scope Guard verification complete");
+  }
+
   if (!scopeResult.ok) {
+    appendTelemetry(root, "gate_finished", { ok: false, code: 3 });
     return { ok: false, code: 3, phases };
   }
 
@@ -150,14 +162,26 @@ export async function gate(opts = {}) {
   const limitBytes = (config.limits.diffKb || 75) * 1024;
   const payloadOk = bytes <= limitBytes;
   phases.push({ phase: "payload", ok: payloadOk, bytes, limitBytes });
+  appendTelemetry(root, "gate_phase", { phase: "payload", ok: payloadOk });
+  if (progressBus && progressToken) {
+    progressBus.reportProgress(progressToken, 50, 100, "Phase 2/4: Diff Payload Governor check complete");
+  }
+
   if (!payloadOk) {
+    appendTelemetry(root, "gate_finished", { ok: false, code: 5 });
     return { ok: false, code: 5, phases };
   }
 
   // Phase 3: Diff Secret Scanner
   const secretResult = scanDiff(diffStr);
   phases.push({ phase: "secrets", ok: secretResult.ok, findings: secretResult.findings });
+  appendTelemetry(root, "gate_phase", { phase: "secrets", ok: secretResult.ok });
+  if (progressBus && progressToken) {
+    progressBus.reportProgress(progressToken, 75, 100, "Phase 3/4: Diff Secret Scanner check complete");
+  }
+
   if (!secretResult.ok) {
+    appendTelemetry(root, "gate_finished", { ok: false, code: 6 });
     return { ok: false, code: 6, phases };
   }
 
@@ -195,6 +219,8 @@ export async function gate(opts = {}) {
       flakyVerdictResult = flakyVerdict(runs);
       if (flakyVerdictResult.verdict === "QUARANTINED") {
         phases.push({ phase: "verify", ok: false, testResult, buildResult, flakyVerdict: flakyVerdictResult });
+        appendTelemetry(root, "gate_phase", { phase: "verify", ok: false, quarantined: true });
+        appendTelemetry(root, "gate_finished", { ok: false, code: 8 });
         return { ok: false, code: 8, phases, flakyVerdict: flakyVerdictResult };
       }
     }
@@ -208,16 +234,25 @@ export async function gate(opts = {}) {
   const verifyOk = testResult.ok && buildResult.ok;
   const failingCmd = !testResult.ok ? testResult : !buildResult.ok ? buildResult : null;
   phases.push({ phase: "verify", ok: verifyOk, testResult, buildResult });
+  appendTelemetry(root, "gate_phase", { phase: "verify", ok: verifyOk });
+  if (progressBus && progressToken) {
+    progressBus.reportProgress(progressToken, 100, 100, "Phase 4/4: Automated Test & Build Verification complete");
+  }
 
   if (!verifyOk && opts.fix) {
-    const repairs = await repair(failingCmd, { config, root, signal: opts.signal });
+    const repairs = await repair(failingCmd, { config, root, signal: opts.signal, progressBus, progressToken });
+    const finalOk = repairs.ok;
+    const finalCode = repairs.ok ? 0 : 4;
+    appendTelemetry(root, "gate_finished", { ok: finalOk, code: finalCode, repaired: true });
     if (repairs.ok) {
       return { ok: true, code: 0, phases, repairs };
     }
     return { ok: false, code: 4, phases, repairs };
   }
 
-  return { ok: verifyOk, code: verifyOk ? 0 : 4, phases };
+  const code = verifyOk ? 0 : 4;
+  appendTelemetry(root, "gate_finished", { ok: verifyOk, code });
+  return { ok: verifyOk, code, phases };
 }
 
 /**
@@ -280,6 +315,8 @@ export async function repair(failure, opts = {}) {
   const config = opts.config || loadConfig(root);
   const maxRetries = config.limits.repairAttempts || 3;
   const provider = opts.provider || createProvider(config.provider, config);
+  const progressBus = opts.progressBus;
+  const progressToken = opts.progressToken;
   const attempts = [];
   const breaker = opts.circuitBreaker || new OODACircuitBreaker({
     windowSize: Math.max(maxRetries + 1, 6),
@@ -292,6 +329,10 @@ export async function repair(failure, opts = {}) {
   breaker.observe(initialFingerprint);
 
   for (let n = 1; n <= maxRetries; n++) {
+    if (progressBus && progressToken) {
+      progressBus.reportProgress(progressToken, Math.round((n / maxRetries) * 100), 100, `OODA Repair attempt ${n}/${maxRetries}`);
+    }
+
     const repairPrompt = buildRepairPrompt(currentFailure, n, config);
     let session;
     try {
@@ -306,13 +347,25 @@ export async function repair(failure, opts = {}) {
       );
     } catch (err) {
       attempts.push({ n, ok: false, error: err.message });
+      appendTelemetry(root, "ooda_repair_attempt", { attempt: n, ok: false, error: err.message });
       break;
     }
 
     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 });
+    const gateRes = await gate({ root, config, fix: false, progressBus, progressToken });
     if (gateRes.ok) {
       breaker.reset();
       return { ok: true, attempts, finalStatus: "PASSED" };
@@ -336,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");
 
@@ -392,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-progress.mjs

@@ -0,0 +1,158 @@
+import { writeMcpFrame } from "./mcp.mjs";
+
+export const MAX_PROGRESS_MESSAGE_LENGTH = 240;
+export const DEFAULT_PROGRESS_COALESCE_MS = 150;
+
+/**
+ * MCP Progress & Event Streaming Bus with 150ms window coalescing and backpressure safety.
+ */
+export class ProgressBus {
+  /**
+   * @param {import("node:stream").Writable} [output=process.stdout]
+   * @param {Object} [opts={}]
+   * @param {number} [opts.coalesceMs=150]
+   */
+  constructor(output = process.stdout, opts = {}) {
+    this.output = output || process.stdout;
+    this.coalesceMs = opts.coalesceMs ?? DEFAULT_PROGRESS_COALESCE_MS;
+    this.pending = new Map(); // token -> { timer, latestPayload }
+    this.queue = [];
+    this.isWriting = false;
+    this.isDraining = false;
+  }
+
+  /**
+   * Internal queue flusher with stream backpressure handling.
+   * @private
+   */
+  async _flushQueue() {
+    this.isWriting = true;
+    while (this.queue.length > 0) {
+      if (this.isDraining) {
+        await new Promise((resolve) => {
+          if (!this.output || typeof this.output.once !== "function") {
+            return resolve();
+          }
+          this.output.once("drain", resolve);
+        });
+        this.isDraining = false;
+      }
+
+      const frame = this.queue.shift();
+      const ok = writeMcpFrame(this.output, frame);
+      if (!ok) {
+        this.isDraining = true;
+      }
+    }
+    this.isWriting = false;
+  }
+
+  /**
+   * Sends a framed JSON-RPC payload to output via authorized writeMcpFrame.
+   * @param {Object} payload
+   */
+  async sendFrame(payload) {
+    const frameStr = JSON.stringify(payload) + "\n";
+    this.queue.push(frameStr);
+    if (!this.isWriting) {
+      await this._flushQueue();
+    }
+  }
+
+  /**
+   * Reports progress for an active progressToken.
+   * Coalesces rapid intermediate updates within a 150ms window (latest-wins).
+   *
+   * @param {string} progressToken
+   * @param {number} progress
+   * @param {number|null} [total=null]
+   * @param {string|null} [message=null]
+   */
+  reportProgress(progressToken, progress, total = null, message = null) {
+    if (!progressToken) return;
+
+    let cappedMessage = undefined;
+    if (message !== null && message !== undefined) {
+      const msgStr = String(message);
+      cappedMessage =
+        msgStr.length > MAX_PROGRESS_MESSAGE_LENGTH
+          ? msgStr.slice(0, MAX_PROGRESS_MESSAGE_LENGTH)
+          : msgStr;
+    }
+
+    const params = {
+      progressToken,
+      progress,
+    };
+    if (total !== null && total !== undefined) params.total = total;
+    if (cappedMessage !== undefined) params.message = cappedMessage;
+
+    const payload = {
+      jsonrpc: "2.0",
+      method: "notifications/progress",
+      params,
+    };
+
+    const isComplete = total !== null && total !== undefined && progress >= total;
+    const existing = this.pending.get(progressToken);
+
+    if (isComplete) {
+      if (existing?.timer) clearTimeout(existing.timer);
+      this.pending.delete(progressToken);
+      this.sendFrame(payload);
+      return;
+    }
+
+    if (!existing) {
+      // First update in window: send immediately
+      this.sendFrame(payload);
+      const timer = setTimeout(() => {
+        const current = this.pending.get(progressToken);
+        if (current?.latestPayload) {
+          this.sendFrame(current.latestPayload);
+        }
+        this.pending.delete(progressToken);
+      }, this.coalesceMs);
+
+      this.pending.set(progressToken, { timer, latestPayload: null });
+    } else {
+      // Intermediate update: save latest payload
+      existing.latestPayload = payload;
+    }
+  }
+
+  /**
+   * Emits an MCP log notification frame (notifications/message).
+   * Never calls raw console.log.
+   *
+   * @param {string} [level="info"] "info" | "warning" | "error" | "debug"
+   * @param {string|Object} [data=""]
+   * @param {string} [logger="jules-orchestrator"]
+   */
+  log(level = "info", data = "", logger = "jules-orchestrator") {
+    const payload = {
+      jsonrpc: "2.0",
+      method: "notifications/message",
+      params: {
+        level,
+        logger,
+        data: typeof data === "string" ? data : JSON.stringify(data),
+      },
+    };
+    return this.sendFrame(payload);
+  }
+
+  /**
+   * Flushes all pending progress timers and ensures output queue is completely drained.
+   */
+  async flush() {
+    for (const [token, item] of this.pending.entries()) {
+      if (item.timer) clearTimeout(item.timer);
+      if (item.latestPayload) {
+        this.sendFrame(item.latestPayload);
+      }
+      this.pending.delete(token);
+    }
+    await this._flushQueue();
+  }
+}

package/src/mcp.mjs

@@ -4,10 +4,12 @@ import { gate, dispatch } from "./engine.mjs";
 import { classifyRiskTier } from "./risk.mjs";
 import { checkDailyBudget, lockStatus } from "./state.mjs";
 import { reapOrphanedIntents, reapStaleMutexDirs } from "./journal.mjs";
+import { readTelemetry } from "./telemetry.mjs";
+import { ProgressBus } from "./mcp-progress.mjs";
 
 export const MCP_SERVER_INFO = {
   name: "jules-orchestrator-kit",
-  version: "0.22.9",
+  version: "0.23.0",
 };
 
 export const MAX_MCP_FRAME_SIZE = 4 * 1024 * 1024; // 4 MB memory safety ceiling
@@ -136,6 +138,16 @@ export const MCP_TOOLS = [
       properties: {},
     },
   },
+  {
+    name: "telemetry_tail",
+    description: "Query the last N telemetry events from the orchestrator telemetry spine.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        limit: { type: "number", description: "Number of telemetry events to retrieve (default 50, max 500)" },
+      },
+    },
+  },
 ];
 
 export async function handleMcpRequest(request, opts = {}) {
@@ -260,6 +272,25 @@ export async function handleMcpRequest(request, opts = {}) {
         };
       }
 
+      if (toolName === "telemetry_tail") {
+        if (args.limit !== undefined && (typeof args.limit !== "number" || args.limit < 1)) {
+          return {
+            jsonrpc: "2.0",
+            id,
+            error: { code: -32602, message: "Invalid parameters: 'limit' must be a positive number" },
+          };
+        }
+        const limit = Math.min(args.limit || 50, 500);
+        const events = readTelemetry(root, limit);
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify(events, null, 2) }],
+          },
+        };
+      }
+
       return {
         jsonrpc: "2.0",
         id,
@@ -361,11 +392,14 @@ export function startMcpServer(input = process.stdin, output = process.stdout, o
     isolateMcpStdout(output, opts);
   }
 
+  const progressBus = opts.progressBus || new ProgressBus(output, opts);
   const decoder = new McpFrameDecoder({ maxFrameSize: opts.maxFrameSize || MAX_MCP_FRAME_SIZE });
 
   decoder.on("data", async (request) => {
     try {
-      const response = await handleMcpRequest(request, opts);
+      const progressToken = request?.params?._meta?.progressToken || request?.params?.progressToken;
+      const requestOpts = { ...opts, progressBus, progressToken };
+      const response = await handleMcpRequest(request, requestOpts);
       if (response !== null && response !== undefined) {
         writeMcpFrame(output, JSON.stringify(response) + "\n");
       }

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/security.mjs

@@ -64,7 +64,9 @@ export function safeAtomicWrite(filePath, content, options = {}) {
   const fd = openSync(tempFile, "wx", mode);
   try {
     writeSync(fd, content, null, encoding);
-    fsyncSync(fd);
+    if (options.sync !== false) {
+      fsyncSync(fd);
+    }
   } finally {
     closeSync(fd);
   }

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

@@ -0,0 +1,311 @@
+import {
+  openSync,
+  writeSync,
+  readSync,
+  closeSync,
+  readFileSync,
+  existsSync,
+  statSync,
+  readdirSync,
+} from "node:fs";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { resolveRoot } from "./config.mjs";
+import { getStateDir, withVfsMutex } from "./state.mjs";
+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.
+ */
+function getTelemetrySegmentFiles(stateDir, dateStr) {
+  if (!existsSync(stateDir)) return [];
+  const prefix = `telemetry-${dateStr}`;
+  const files = readdirSync(stateDir).filter(
+    (f) => f.startsWith(prefix) && f.endsWith(".jsonl")
+  );
+
+  return files
+    .map((name) => {
+      let index = 0;
+      if (name !== `${prefix}.jsonl`) {
+        const match = name.match(/telemetry-[0-9]{4}-[0-9]{2}-[0-9]{2}-([0-9]+)\.jsonl$/);
+        if (match) index = parseInt(match[1], 10);
+      }
+      return { name, path: join(stateDir, name), index };
+    })
+    .sort((a, b) => a.index - b.index);
+}
+
+/**
+ * Performs a cold scan of telemetry jsonl files to recover the last valid hash and active segment index.
+ */
+function coldScanTelemetry(stateDir, dateStr) {
+  const segments = getTelemetrySegmentFiles(stateDir, dateStr);
+  if (segments.length === 0) {
+    return { hash: TELEMETRY_GENESIS_HASH, segment: 0 };
+  }
+
+  for (let i = segments.length - 1; i >= 0; i--) {
+    const seg = segments[i];
+    if (existsSync(seg.path)) {
+      const tailHash = readTailHash(seg.path);
+      if (tailHash) {
+        return { hash: tailHash, segment: seg.index };
+      }
+    }
+  }
+
+  return { hash: TELEMETRY_GENESIS_HASH, segment: 0 };
+}
+
+/**
+ * Appends a structured telemetry event to .agent/state/telemetry-<date>.jsonl with SHA-256 hash chaining.
+ * Uses .head atomic cache with true tail reconciliation for O(1) constant-time appends.
+ *
+ * @param {string} [rootOrOpts]
+ * @param {string} kind
+ * @param {Object} [fields={}]
+ * @returns {Object} Appended telemetry record
+ */
+export function appendTelemetry(rootOrOpts = resolveRoot(), kind = "event", fields = {}) {
+  const root = typeof rootOrOpts === "string" ? rootOrOpts : resolveRoot();
+  const stateDir = getStateDir(root);
+  const mutexDir = join(stateDir, ".telemetry.mutex");
+
+  return withVfsMutex(mutexDir, () => {
+    const dateStr = new Date().toISOString().split("T")[0];
+    const headPath = join(stateDir, `telemetry-${dateStr}.head`);
+
+    let prevHash = TELEMETRY_GENESIS_HASH;
+    let activeSegmentIndex = 0;
+    let headValid = false;
+
+    if (existsSync(headPath)) {
+      try {
+        const headContent = readFileSync(headPath, "utf-8");
+        const headObj = JSON.parse(headContent);
+        if (headObj && typeof headObj.hash === "string") {
+          prevHash = headObj.hash;
+          activeSegmentIndex = typeof headObj.segment === "number" ? headObj.segment : 0;
+          headValid = true;
+        }
+      } catch (_) {}
+    }
+
+    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);
+        if (stat.size >= MAX_TELEMETRY_SEGMENT_BYTES) {
+          activeSegmentIndex += 1;
+          activeFileName = `telemetry-${dateStr}-${activeSegmentIndex}.jsonl`;
+          activeFilePath = join(stateDir, activeFileName);
+        }
+      } catch (_) {}
+    }
+
+    const ts = new Date().toISOString();
+    const payloadWithoutHash = { v: 1, ts, kind, ...fields, prevHash };
+    const hash = createHash("sha256").update(JSON.stringify(payloadWithoutHash)).digest("hex");
+    const entry = { ...payloadWithoutHash, hash };
+
+    const fd = openSync(activeFilePath, "a");
+    try {
+      writeSync(fd, JSON.stringify(entry) + "\n", "utf-8");
+    } finally {
+      closeSync(fd);
+    }
+
+    safeAtomicWrite(
+      headPath,
+      JSON.stringify({ v: 1, hash, segment: activeSegmentIndex, ts }),
+      { sync: false }
+    );
+
+    return entry;
+  });
+}
+
+/**
+ * Reads telemetry records across segments for a target date (or current date if omitted).
+ * Returns array of telemetry objects in chronological order.
+ *
+ * @param {string} [rootOrOpts]
+ * @param {number} [limit=50]
+ * @param {string} [targetDateStr]
+ * @returns {Array<Object>}
+ */
+export function readTelemetry(rootOrOpts = resolveRoot(), limit = 50, targetDateStr = null) {
+  const root = typeof rootOrOpts === "string" ? rootOrOpts : resolveRoot();
+  const stateDir = getStateDir(root);
+  const dateStr = targetDateStr || new Date().toISOString().split("T")[0];
+
+  const segments = getTelemetrySegmentFiles(stateDir, dateStr);
+  if (segments.length === 0) return [];
+
+  const allEntries = [];
+  for (const seg of segments) {
+    if (existsSync(seg.path)) {
+      try {
+        const raw = readFileSync(seg.path, "utf-8");
+        const lines = raw.split("\n").filter(Boolean);
+        for (const line of lines) {
+          try {
+            const entry = JSON.parse(line);
+            allEntries.push(Object.freeze(entry));
+          } catch (_) {}
+        }
+      } catch (_) {}
+    }
+  }
+
+  if (allEntries.length <= limit) {
+    return allEntries;
+  }
+  return allEntries.slice(allEntries.length - limit);
+}
+
+/**
+ * Verifies the cryptographic SHA-256 hash-chain integrity of telemetry records for a date.
+ *
+ * @param {string} [rootOrOpts]
+ * @param {string} [targetDateStr]
+ * @returns {Object}
+ */
+export function verifyTelemetryIntegrity(rootOrOpts = resolveRoot(), targetDateStr = null) {
+  const root = typeof rootOrOpts === "string" ? rootOrOpts : resolveRoot();
+  const stateDir = getStateDir(root);
+  const dateStr = targetDateStr || new Date().toISOString().split("T")[0];
+
+  const segments = getTelemetrySegmentFiles(stateDir, dateStr);
+  if (segments.length === 0) {
+    return { ok: true, count: 0, lastHash: TELEMETRY_GENESIS_HASH };
+  }
+
+  let expectedPrevHash = TELEMETRY_GENESIS_HASH;
+  let totalCount = 0;
+
+  for (const seg of segments) {
+    if (!existsSync(seg.path)) continue;
+    try {
+      const raw = readFileSync(seg.path, "utf-8");
+      const lines = raw.split("\n").filter(Boolean);
+      for (let i = 0; i < lines.length; i++) {
+        totalCount++;
+        let obj;
+        try {
+          obj = JSON.parse(lines[i]);
+        } catch (err) {
+          return { ok: false, segment: seg.name, line: i + 1, error: "TORN_WRITE_CORRUPTION", detail: err.message };
+        }
+
+        if (!obj.hash || !obj.prevHash) {
+          return { ok: false, segment: seg.name, line: i + 1, error: "MISSING_HASH_FIELDS" };
+        }
+
+        if (obj.prevHash !== expectedPrevHash) {
+          return {
+            ok: false,
+            segment: seg.name,
+            line: i + 1,
+            error: "BROKEN_PREV_HASH",
+            expected: expectedPrevHash,
+            actual: obj.prevHash,
+          };
+        }
+
+        const { hash, ...rest } = obj;
+        const recomputed = createHash("sha256").update(JSON.stringify(rest)).digest("hex");
+        if (recomputed !== hash) {
+          return {
+            ok: false,
+            segment: seg.name,
+            line: i + 1,
+            error: "CORRUPTED_ENTRY_HASH",
+            expected: recomputed,
+            actual: hash,
+          };
+        }
+        expectedPrevHash = hash;
+      }
+    } catch (err) {
+      return { ok: false, count: totalCount, error: err.message };
+    }
+  }
+
+  const headPath = join(stateDir, `telemetry-${dateStr}.head`);
+  if (existsSync(headPath)) {
+    try {
+      const headObj = JSON.parse(readFileSync(headPath, "utf-8"));
+      if (headObj.hash !== expectedPrevHash) {
+        return {
+          ok: false,
+          error: "HEAD_HASH_MISMATCH",
+          expected: expectedPrevHash,
+          actual: headObj.hash,
+        };
+      }
+    } catch (_) {
+      return { ok: false, error: "CORRUPTED_HEAD_FILE" };
+    }
+  }
+
+  return { ok: true, count: totalCount, lastHash: expectedPrevHash };
+}

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