jules-orchestrator-kit 0.72.2 → 0.73.0

package/src/todo-scanner.mjs

@@ -0,0 +1,129 @@
+/**
+ * Codebase scanner for TODO and FIXME comments.
+ *
+ * Safety limits: only source-ish extensions are read, files larger than
+ * SCAN_MAX_FILE_BYTES are skipped, buffers containing null bytes are treated
+ * as binary and skipped, and paths matched by the scan root's .gitignore are
+ * never descended into or read.
+ *
+ * This is the home of the scanner that used to live in
+ * `scripts/jules-scan-todos.mjs`; that file is now a minimal CLI entry point.
+ */
+
+import { readdirSync, readFileSync, statSync, existsSync } from "node:fs";
+import { join, extname, relative } from "node:path";
+
+export const SCAN_ALLOWED_EXTENSIONS = new Set([".js", ".mjs", ".ts", ".py", ".rs", ".go", ".md"]);
+export const SCAN_MAX_FILE_BYTES = 1024 * 1024;
+
+function globToRegExp(glob) {
+  let out = "";
+  for (let i = 0; i < glob.length; i++) {
+    const ch = glob[i];
+    if (ch === "*") {
+      if (glob[i + 1] === "*") {
+        out += ".*";
+        i++;
+        if (glob[i + 1] === "/") i++;
+      } else {
+        out += "[^/]*";
+      }
+    } else if (ch === "?") {
+      out += "[^/]";
+    } else {
+      out += ch.replace(/[.*+?^${}()|[\]\\]/, "\\$&");
+    }
+  }
+  return new RegExp(`^${out}$`);
+}
+
+function loadGitignorePatterns(dir) {
+  const ignoreFile = join(dir, ".gitignore");
+  if (!existsSync(ignoreFile)) return [];
+  let raw;
+  try {
+    raw = readFileSync(ignoreFile, "utf-8");
+  } catch (_) {
+    return [];
+  }
+  const patterns = [];
+  for (let line of raw.split("\n")) {
+    line = line.trim();
+    if (!line || line.startsWith("#")) continue;
+    let negated = false;
+    if (line.startsWith("!")) {
+      negated = true;
+      line = line.slice(1).trim();
+      if (!line) continue;
+    }
+    if (line.startsWith("/")) line = line.slice(1);
+    const dirOnly = line.endsWith("/");
+    if (dirOnly) line = line.slice(0, -1);
+    const hasSlash = line.includes("/");
+    patterns.push({ negated, dirOnly, hasSlash, regex: globToRegExp(line), literal: line });
+  }
+  return patterns;
+}
+
+function isIgnored(relPath, isDir, patterns) {
+  if (patterns.length === 0) return false;
+  const base = relPath.split("/").pop();
+  let ignored = false;
+  for (const p of patterns) {
+    // A file pattern also ignores everything beneath a matched directory.
+    const candidate = p.hasSlash ? relPath : base;
+    let hit = p.regex.test(candidate);
+    if (!hit && p.dirOnly && (relPath === p.literal || relPath.startsWith(`${p.literal}/`))) hit = true;
+    if (!hit && p.hasSlash && relPath.startsWith(`${p.literal}/`)) hit = true;
+    if (hit && !(p.dirOnly && !isDir && !relPath.startsWith(`${p.literal}/`))) {
+      ignored = !p.negated;
+    }
+  }
+  return ignored;
+}
+
+export function scanCodebaseForTodos(dir = process.cwd()) {
+  const todos = [];
+  const patterns = loadGitignorePatterns(dir);
+  function walk(current) {
+    let entries = [];
+    try { entries = readdirSync(current); } catch (_) { return; }
+    for (const entry of entries) {
+      if (entry === "node_modules" || entry === ".git") continue;
+      const full = join(current, entry);
+      try {
+        const stat = statSync(full);
+        const rel = relative(dir, full).split("\\").join("/");
+        if (rel && isIgnored(rel, stat.isDirectory(), patterns)) continue;
+        if (stat.isDirectory()) {
+          walk(full);
+        } else if (stat.isFile()) {
+          if (!SCAN_ALLOWED_EXTENSIONS.has(extname(entry).toLowerCase())) continue;
+          if (stat.size > SCAN_MAX_FILE_BYTES) continue;
+          let content;
+          try {
+            content = readFileSync(full);
+          } catch (_) {
+            continue;
+          }
+          if (content.includes(0)) continue;
+          const lines = content.toString("utf-8").split("\n");
+          lines.forEach((line, idx) => {
+            if (line.includes("TODO:")) {
+              todos.push({ file: full, line: idx + 1, text: line.trim(), tag: "TODO", type: "TODO", priority: "MEDIUM" });
+            } else if (line.includes("FIXME:")) {
+              todos.push({ file: full, line: idx + 1, text: line.trim(), tag: "FIXME", type: "FIXME", priority: "HIGH" });
+            }
+          });
+        }
+      } catch (_) {}
+    }
+  }
+  walk(dir);
+  return todos;
+}
+
+export function runScanner(dir = process.cwd()) {
+  const todos = scanCodebaseForTodos(dir);
+  return { todos, count: todos.length };
+}

package/src/web-templates.mjs

@@ -388,13 +388,13 @@ The test must fail on a hand-broken fixture before you consider it done.`;
 1. **Prove Each Test Can Fail (Mutation Falsification)**:
    - For every test in scope, deliberately introduce a defect into the code under test (${strategy}), run only that test, and confirm it turns red.
    - Immediately revert every deliberate code mutation before proceeding to the next test.
-   - A test nobody has seen fail is an unverified assumption; delete or rewrite tests that remain green under deliberate mutation.
+   - A test nobody has seen fail is an unverified assumption; add targeted assertions or classify equivalent mutants for tests that remain green under deliberate mutation. Never delete surviving tests.
 2. **Eliminate Vacuous & Tautological Checks**:
    - Strip tests that mock the subject under test (measuring the mock rather than the implementation).
    - Replace shallow shape assertions (\`toBeDefined()\`, \`assertTrue(result)\`, \`is not None\`) with precise value assertions derived from requirements.
 3. **Reconcile Collected vs Passed Counts**:
    - Compare test runner collected test count against actual test function count to detect uncollected or silently ignored test files.
-   - Document every deleted tautological test with its specific failure mode.`;
+   - Document every purged tautological test with its specific failure mode.`;
     }
   },
 
@@ -920,7 +920,7 @@ export function synthesizeWebEnvelope(templateId, userParams = {}, options = {})
 
   if (explorationBudget) {
     lines.push("## Google Labs Exploration Budget Protocol (3-Phase Discovery)");
-    lines.push("To maximize diagnostic accuracy (Hit@5 57%), execute this task in 3 distinct phases:");
+    lines.push("Use deep planning mode. execute this task in 3 distinct phases (Discovery, Test Formulation, Surgical Implementation):");
     lines.push("1. **PHASE 1: DISCOVERY & SYMBOL TRACING (Stay Silent, Write NO Code)**");
     lines.push("   - Read target component files, CSS definitions, imports, and existing test specs.");
     lines.push("   - Formulate diagnostic hypothesis and verify symbol signatures before planning edits.");

package/src/webhook.mjs

@@ -465,7 +465,7 @@ export async function dispatchEscalation(incident = {}, config = {}) {
 
 /**
  * Verify GitHub webhook HMAC SHA-256 signature against request payload.
- * @param {Buffer|string} payload - Raw request body
+ * @param {Uint8Array|string} payload - Raw request body
  * @param {string} signatureHeader - Value of X-Hub-Signature-256 header
  * @param {string} secret - Configured webhook secret
  * @returns {boolean} True if signature matches
@@ -493,7 +493,7 @@ export function verifySignature(payload, signatureHeader, secret) {
 
 /**
  * Parse incoming webhook body buffer into a JS object.
- * @param {Buffer|Uint8Array|string} bodyBuf 
+ * @param {Uint8Array|string} bodyBuf
  * @param {string} contentType 
  * @returns {object} Parsed JSON payload
  */
@@ -620,7 +620,14 @@ export function createWebhookServer({ port = 8787, secret = process.env.JULES_WE
 
     req.on("end", () => {
       if (totalSize > MAX_BODY) return;
-      const bodyBuf = Buffer.concat(chunks);
+
+      const bodyBuf = new Uint8Array(totalSize);
+      let offset = 0;
+      for (const chunk of chunks) {
+        bodyBuf.set(chunk, offset);
+        offset += chunk.length;
+      }
+
       const sigHeader = req.headers["x-hub-signature-256"];
       const eventType = req.headers["x-github-event"];
       const contentType = req.headers["content-type"] || "application/json";

package/src/wizard-init.mjs

@@ -1,6 +1,7 @@
-import { existsSync, readFileSync, writeFileSync, openSync, fsyncSync, closeSync, renameSync, mkdirSync, readdirSync } from "node:fs";
+import { existsSync, readFileSync, mkdirSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { parseYaml, yamlScalar, TIER_PRESETS, VENDOR_TIERS, FALLBACK_TIER } from "./config.mjs";
+import { safeAtomicWrite } from "./security.mjs";
 import { suggestProvider, detectAvailableProviders } from "./provider-readiness.mjs";
 import { detectDefaultBranch } from "./git.mjs";
 import { resolveWorkspaceBoundary, oracleCandidates } from "./stack-detector.mjs";
@@ -10,23 +11,6 @@ import { parseCollectedTests, producedNoOutput, looksLikeTestSuiteCommand } from
 import { select, multiSelect, input, confirm, spinner, isTTY } from "./tui.mjs";
 import { KIT_VERSION } from "./version.mjs";
 
-/**
- * Write a file atomically using a temporary file and atomic rename.
- * @param {string} filePath
- * @param {string} content
- */
-function writeAtomic(filePath, content) {
-  const tmpPath = `${filePath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
-  const fd = openSync(tmpPath, "w");
-  try {
-    writeFileSync(fd, content, "utf-8");
-    fsyncSync(fd);
-  } finally {
-    closeSync(fd);
-  }
-  renameSync(tmpPath, filePath);
-}
-
 /**
  * Snake_case projection of {@link TIER_PRESETS} for the YAML the wizard writes.
  * Derived rather than declared: as a second literal table it drifted out of sync
@@ -125,6 +109,14 @@ export function planInit(root = process.cwd(), options = {}) {
   // a 100-task budget and 8 concurrent workers it does not have. The same
   // reasoning makes FALLBACK_TIER conservative in loadConfig(); the wizard has
   // to agree with it or the manifest guards a ceiling the runtime does not.
+  const validTiers = Object.keys(TIER_PRESETS);
+  if (options.tier && !validTiers.includes(String(options.tier).toLowerCase())) {
+    const rawTier = String(options.tier).toLowerCase();
+    if (["minimal", "standard", "max"].includes(rawTier)) {
+      throw new Error(`Invalid tier "${options.tier}". Valid tiers: ${validTiers.join(", ")}. Did you mean '--profile ${options.tier}'?`);
+    }
+    throw new Error(`Invalid tier "${options.tier}". Valid tiers: ${validTiers.join(", ")}.`);
+  }
   const tierName = options.tier || FALLBACK_TIER;
   // An unrecognised name resolves the same way loadConfig() resolves it, so the
   // scaffolded limits always match what the runtime will later enforce.
@@ -572,8 +564,8 @@ export async function runInitWizard(root = process.cwd(), options = {}) {
   const configPath = join(agentDir, "config.yml");
   const julesPath = join(agentDir, "jules.yml");
 
-  writeAtomic(configPath, plan.configYaml);
-  writeAtomic(julesPath, plan.julesYaml);
+  safeAtomicWrite(configPath, plan.configYaml);
+  safeAtomicWrite(julesPath, plan.julesYaml);
 
   return {
     ok: true,

package/src/wizard-oracle.mjs

@@ -3,6 +3,7 @@ import { join } from "node:path";
 import { spawnSync } from "node:child_process";
 import { detectStack, parseYaml } from "./config.mjs";
 import { runCmd } from "./git.mjs";
+import { pytestCmd } from "./stack-detector.mjs";
 
 /**
  * Check if a command-line binary is available on the system PATH.
@@ -92,7 +93,7 @@ export function detectStackOracles(root = process.cwd()) {
   }
 
   // Check Go module
-  if (stack.includes("go") || existsSync(join(root, "go.mod"))) {
+  if (stack === "go" || existsSync(join(root, "go.mod"))) {
     candidates.testCmd = candidates.testCmd || "go test ./...";
     candidates.buildCmd = candidates.buildCmd || "go build ./...";
     if (hasBinary("golangci-lint")) {
@@ -102,8 +103,8 @@ export function detectStackOracles(root = process.cwd()) {
   }
 
   // Check Python
-  if (stack.includes("pytest") || existsSync(join(root, "pyproject.toml")) || existsSync(join(root, "requirements.txt"))) {
-    candidates.testCmd = candidates.testCmd || "pytest";
+  if (stack === "python" || stack === "django" || existsSync(join(root, "pyproject.toml")) || existsSync(join(root, "requirements.txt"))) {
+    candidates.testCmd = candidates.testCmd || pytestCmd(process.env, root);
     candidates.buildCmd = candidates.buildCmd || "";
     if (hasBinary("flake8")) {
       candidates.lintCmd = candidates.lintCmd || "flake8 .";

package/src/wizard-task.mjs

@@ -1,10 +1,11 @@
 import { writeFileSync, mkdirSync, existsSync } from "node:fs";
 import { resolve } from "node:path";
+import { untrackedOnboardingArtifacts } from "./git.mjs";
 import { loadConfig } from "./config.mjs";
 import { gate } from "./engine.mjs";
 import { scanDiff, shannonEntropy } from "./security.mjs";
 import { getQueueDir } from "./state.mjs";
-import { scanCodebaseForTodos } from "../scripts/jules-scan-todos.mjs";
+import { scanCodebaseForTodos } from "./todo-scanner.mjs";
 import { select, input, confirm, spinner, isTTY } from "./tui.mjs";
 import { scorePromptFalsifiability } from "./task-optimizer.mjs";
 import { getWebTemplate, synthesizeWebEnvelope } from "./web-templates.mjs";
@@ -110,16 +111,21 @@ export function planTaskCreate(root = process.cwd(), inputObj = {}) {
   const config = loadConfig(root);
 
   let title = inputObj.title;
-  let rawPrompt = inputObj.prompt || "";
+  let rawPrompt = (inputObj.prompt || "").trim();
   let verifyCmd = (inputObj.verifyCmd || config.verify.test || config.verify.build || "").trim();
 
+  // Validate that a task objective or template was provided before injecting role instructions
+  if (!rawPrompt && !inputObj.template) {
+    throw new Error("Task prompt cannot be empty.");
+  }
+
   // 0a. Process Specialist Role if specified
   let resolvedRole = null;
   if (inputObj.role) {
-    resolvedRole = resolveRolePrompt(root, inputObj.role);
+    resolvedRole = resolveRolePrompt(root, inputObj.role, { config });
     if (!resolvedRole) {
       throw new Error(
-        `Unknown agent role '${inputObj.role}'. Expected matching prompt file in .agent/prompts/ (e.g. Overseer, Bolt, Sentinel, Janitor).`
+        `Unknown agent role '${inputObj.role}'. Expected matching prompt file in .agent/prompts/ (e.g. Auditor, Performance, Security, Hygiene, Testing).`
       );
     }
     rawPrompt = `${resolvedRole.content}\n\n${rawPrompt}`.trim();
@@ -164,8 +170,19 @@ export function planTaskCreate(root = process.cwd(), inputObj = {}) {
   if (!secretScan.ok) {
     secretScan.findings.forEach((f) => secretFindings.push({ id: f.type || f.id || "SECRET_LEAK", ...f }));
   }
-  const hasHighEntropyToken = rawPrompt.split(/\s+/).some((token) => token.length >= 20 && shannonEntropy(token) > 4.3);
-  const isShortHighEntropy = rawPrompt.length <= 120 && shannonEntropy(rawPrompt) > 4.5;
+  const isPathOrUrlToken = (str) => {
+    const clean = str.replace(/^[(\[{<`"']+|[)\]}>`"',;:]+$/g, "");
+    if (/^(https?|file|ftp|vscode|git|ssh|node):/i.test(clean)) return true;
+    if (/^[a-zA-Z]:[/\\]/.test(clean)) return true;
+    if (/^[./~\\]/.test(clean)) return true;
+    if (/[/\\][a-zA-Z0-9_.-]+\.[a-zA-Z0-9]+(:\d+(:\d+)?)?$/.test(clean)) return true;
+    return false;
+  };
+  const hasHighEntropyToken = rawPrompt
+    .split(/\s+/)
+    .some((token) => !isPathOrUrlToken(token) && token.length >= 20 && shannonEntropy(token) > 4.3);
+  const isShortHighEntropy =
+    rawPrompt.length <= 120 && !isPathOrUrlToken(rawPrompt.trim()) && shannonEntropy(rawPrompt) > 4.5;
   if ((hasHighEntropyToken || isShortHighEntropy) && !inputObj.allowHighEntropy) {
     secretFindings.push({ id: "HIGH_ENTROPY_PROMPT", line: 1 });
   }
@@ -344,9 +361,20 @@ export async function runTaskCreateWizard(root = process.cwd(), options = {}) {
   // Perform Gate Preflight
   const gateRes = await gate({ root, mode: "working-tree" });
   if (!gateRes.ok && (gateRes.code === 3 || gateRes.code === 6) && !options.allowGateFailure) {
-    // Filter out uncommitted .agent/ config scope warnings if user initialized locally
-    const realViolations = gateRes.phases[0]?.violations?.filter((v) => !v.file.startsWith(".agent/")) || [];
-    if (realViolations.length > 0 || gateRes.code === 6) {
+    const scopeViolations = gateRes.phases[0]?.violations || [];
+    // A cold-start repository has nothing committed yet: every path init just
+    // wrote — the .agent/ manifest, and the package.json / lockfile a fresh
+    // `npm install` produced — reads as a scope violation because nothing is
+    // on the base branch. Failing task creation on scaffolding the user cannot
+    // have committed *before* installing the tool is a dead end. Untracked
+    // root package-manager artifacts are just-run-install output (not a
+    // dependency change the maintainer shipped), so they are filtered out the
+    // same way the .agent/ scaffolding already is. A modified *tracked*
+    // lockfile stays protected and still rejects the task.
+    const realViolations = scopeViolations.filter((v) => !v.file.startsWith(".agent/")) || [];
+    const installArtifacts = new Set(untrackedOnboardingArtifacts(root, scopeViolations.map((v) => v.file)));
+    const blockers = realViolations.filter((v) => !installArtifacts.has(v.file));
+    if (blockers.length > 0 || gateRes.code === 6) {
       throw new Error(`Gate Preflight Rejected Task: Repository contains scope or secret violations (Exit ${gateRes.code}).`);
     }
   }

package/.agent/prompts/Sentinel.md

@@ -1,18 +0,0 @@
-# Sentinel - Security Audit & Hardening Specialist 🛡️
-
-> **Role:** Codebase Security Auditor & AST Vulnerability Scanner.
-> **Scope:** Input sanitization, secret scanning, RBAC verification, and prompt injection defense.
-
-## Core Directives
-
-1. **Vulnerability Mitigation:**
-   - Scan for unescaped SQL queries, `eval()`, dynamic `exec()`, or unvalidated shell arguments.
-   - Enforce explicit input validation and type coercion on all external API entry points.
-
-2. **Secret Leak Prevention:**
-   - Ensure credentials, private keys, API tokens, and JWT secrets are loaded strictly from `process.env`.
-   - Never log sensitive tokens or unmasked PII into console logs or file artifacts.
-
-3. **Untrusted Fencing:**
-   - Label user-controllable input data with `<UNTRUSTED>` fencing tags.
-   - Instruct parsing logic to fail-closed on malformed or malicious payload structures.

package/scripts/utils.mjs

@@ -1,241 +0,0 @@
-/**
- * Common scripting utilities and helper functions.
- */
-
-import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { randomUUID } from "node:crypto";
-import os from "node:os";
-import { resolveRoot } from "../src/config.mjs";
-import { appendLedger, checkDailyBudget as baseCheckDailyBudget, verifyLedgerIntegrity as baseVerifyLedgerIntegrity } from "../src/state.mjs";
-
-export { loadConfig, resolveRoot, normalizePath } from "../src/config.mjs";
-export {
-  shannonEntropy,
-  shannonEntropy as calculateShannonEntropy,
-  redactSecrets,
-  anonymizePii,
-  matchesGlob,
-  isForbiddenPath,
-  hasHighConfidenceSecret,
-  hasLowConfidenceSecret,
-  HIGH_CONFIDENCE_PATTERNS,
-  LOW_CONFIDENCE_PATTERNS,
-} from "../src/security.mjs";
-export { git, runCmd } from "../src/git.mjs";
-export { appendLedger, getDailyLedgerPath, ensureDir } from "../src/state.mjs";
-
-export const log = {
-  info: (msg) => console.log(`ℹ️  ${msg}`),
-  success: (msg) => console.log(`✅ ${msg}`),
-  warn: (msg) => console.warn(`⚠️  ${msg}`),
-  error: (msg) => console.error(`❌ ${msg}`),
-  step: (stepStr, msg) => console.log(`${stepStr} ${msg}`),
-  dim: (msg) => console.log(msg),
-  header: (msg) => console.log(`\n=== ${msg} ===\n`),
-  groupEnd: () => {},
-};
-
-export function timestamp() {
-  return new Date().toISOString();
-}
-
-export function loadEnv(targetDir = process.cwd()) {
-  const envPath = join(targetDir, ".env");
-  if (!existsSync(envPath)) return;
-  try {
-    const raw = readFileSync(envPath, "utf-8");
-    for (const line of raw.split(/\r?\n/)) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      const clean = trimmed.startsWith("export ") ? trimmed.slice(7).trim() : trimmed;
-      const eqIdx = clean.indexOf("=");
-      if (eqIdx > 0) {
-        const k = clean.slice(0, eqIdx).trim();
-        let v = clean.slice(eqIdx + 1).trim();
-        if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) {
-          v = v.slice(1, -1);
-        }
-        process.env[k] = v;
-      }
-    }
-  } catch (_) {}
-}
-
-export function getIsolatedCacheDir() {
-  return process.env.JULES_CACHE_DIR ? resolve(process.env.JULES_CACHE_DIR) : join(os.homedir(), ".cache", "jules-orchestrator-kit");
-}
-
-export function ensureSdkCacheIsolation() {
-  const dir = getIsolatedCacheDir();
-  if (!existsSync(dir)) {
-    try { mkdirSync(dir, { recursive: true }); } catch (_) {}
-  }
-  process.env.JULES_CACHE_DIR = dir;
-  return dir;
-}
-
-export function logToHistory(filename, content) {
-  const dateStr = new Date().toISOString().split("T")[0];
-  const historyDir = resolve(process.env.JULES_PROJECT_ROOT || process.cwd(), ".agent/history");
-  if (!existsSync(historyDir)) {
-    try { mkdirSync(historyDir, { recursive: true }); } catch (_) {}
-  }
-  const filePath = join(historyDir, `${dateStr}-${filename}`);
-  try { writeFileSync(filePath, content, "utf-8"); } catch (_) {}
-  return filePath;
-}
-
-export function resolveMarkdownConflict(content) {
-  if (!content || typeof content !== "string") return "";
-  const lines = content.split("\n");
-  const result = [];
-  for (const line of lines) {
-    if (line.startsWith("<<<<<<<") || line.startsWith("=======") || line.startsWith(">>>>>>>")) {
-      continue;
-    }
-    result.push(line);
-  }
-  return result.join("\n");
-}
-
-export function pruneOldLedgers(stateDir, retentionDays = 30) {
-  if (!existsSync(stateDir)) return;
-  const cutoff = Date.now() - retentionDays * 86400 * 1000;
-  try {
-    const files = readdirSync(stateDir);
-    for (const f of files) {
-      const full = join(stateDir, f);
-      try {
-        const stat = statSync(full);
-        if (stat.isFile() && stat.mtimeMs < cutoff) {
-          unlinkSync(full);
-        }
-      } catch (_) {}
-    }
-  } catch (_) {}
-}
-
-export function checkDailyBudget(arg1 = resolveRoot(), arg2 = 300) {
-  let root = typeof arg1 === "string" ? arg1 : resolveRoot();
-  let limit = typeof arg1 === "number" ? arg1 : (typeof arg2 === "number" ? arg2 : 300);
-
-  const res = baseCheckDailyBudget(root, limit);
-  // Filter for budget_reserved events if present
-  const ledgerPath = join(root, `.agent/state/ledger-${new Date().toISOString().split("T")[0]}.jsonl`);
-  if (existsSync(ledgerPath)) {
-    try {
-      const lines = readFileSync(ledgerPath, "utf-8").split("\n").filter(Boolean);
-      const reservedCount = lines.filter((l) => l.includes('"event":"budget_reserved"')).length;
-      if (reservedCount > 0) {
-        return { ok: reservedCount < limit, used: reservedCount, budget: limit, remaining: Math.max(0, limit - reservedCount) };
-      }
-    } catch (_) {}
-  }
-  return res;
-}
-
-/**
- * @param {number} [maxSessions=300]
- * @param {string} [taskKey=""]
- * @param {string} [root] - Ledger root. Defaults to the git toplevel. Pass an
- *   explicit root to keep callers (notably tests) off the operator's real ledger.
- */
-export function reserveDailyBudget(maxSessions = 300, taskKey = "", root = resolveRoot()) {
-  // The id is what makes the reservation releasable. Written without one, a
-  // reservation counted against the day and no rollback, commit or reconcile
-  // could ever name it again — it stayed charged until the ledger rotated.
-  const reservationId = `res-${Date.now()}-${randomUUID().slice(0, 8)}`;
-  appendLedger({ event: "budget_reserved", reservationId, key: taskKey }, root);
-  const check = checkDailyBudget(root, maxSessions);
-  return { ok: check.ok, used: check.used, budget: maxSessions, reservationId };
-}
-
-export function verifyLedgerIntegrity(filePath) {
-  if (!existsSync(filePath)) return { ok: false, count: 0 };
-  try {
-    const lines = readFileSync(filePath, "utf-8").split("\n").filter(Boolean);
-    let hasHashes = true;
-    for (const line of lines) {
-      const obj = JSON.parse(line);
-      if (!obj.hash) hasHashes = false;
-    }
-    if (hasHashes && lines.length > 0) {
-      return baseVerifyLedgerIntegrity(filePath);
-    }
-    return { ok: true, count: lines.length, lastHash: "sha256-verified" };
-  } catch (err) {
-    return { ok: false, count: 0, error: err.message || "Invalid JSON in ledger" };
-  }
-}
-
-export function acquireBudgetLock(_root) {
-  return true;
-}
-
-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 };
-}
-