jules-orchestrator-kit 0.38.0 → 0.38.2

package/bin/agentctl.mjs

@@ -46,7 +46,7 @@ Commands:
   swarm                 Run parallel task swarm
   mcp                   Start stdio Model Context Protocol (MCP) server
   clean                 Clean stale branches, worktrees, locks, and ledgers
-  lock <action>         Manage mutex locks (acquire | release | status | cleanup)
+  lock <action>         Manage mutex locks (acquire | release | status)
   doctor                Run system diagnostics and stack resolution checks
   bootstrap             Bootstrap zero-test repository with verification oracle
   review-repair         Parse PR review comments and synthesize OODA repair tasks
@@ -58,6 +58,7 @@ Commands:
   test-gen              Scaffold & run automated TDD Red-to-Green test cycle (--run)
   mcp init              Scaffold IDE integration config (cursor | vscode | claude | all)
   rollback              Restore git state & working tree to atomic pre-flight checkpoint
+  handover              Inspect or generate Baton Pass session handover envelopes (list | show | create | prune)
   resume                Resume warm session with human response (--response "<text>")
   escalate              Dispatch or manage webhook escalation incidents (--flush, --status, --clear)
   flaky                 Manage Wilson-quarantined tests and dispatch healing swarm (status | heal | reset)
@@ -259,6 +260,25 @@ async function main() {
         }
         console.log(`-----------------------------------------------------`);
         console.log(`Overall Result: ${res.ok ? "APPROVED (Exit 0)" : `REJECTED (Exit ${res.code})`}\n`);
+        if (!res.ok) {
+          if (res.code === 3) {
+            console.log(`💡 Remediation Hint (Exit 3 Scope Violation):`);
+            console.log(`   • To allow protected files in this run, pass: agentctl gate --allow-protected`);
+            console.log(`   • Or remove protected/denied paths from the diff before dispatching.\n`);
+          } else if (res.code === 5) {
+            console.log(`💡 Remediation Hint (Exit 5 Diff Payload Overflow):`);
+            console.log(`   • Total diff exceeds ${config.limits?.diffKb || 75} KB limit.`);
+            console.log(`   • Split the task into smaller atomic tasks using: agentctl task create\n`);
+          } else if (res.code === 6) {
+            console.log(`💡 Remediation Hint (Exit 6 Secret Leak Prevented):`);
+            console.log(`   • High-entropy credential or secret detected in patch.`);
+            console.log(`   • Scrub credential from source and rotate any exposed keys immediately.\n`);
+          } else if (res.code === 4) {
+            console.log(`💡 Remediation Hint (Exit 4 OODA Repair Exhausted):`);
+            console.log(`   • Automated self-repair could not pass tests cleanly.`);
+            console.log(`   • Review error fingerprints via: agentctl doctor\n`);
+          }
+        }
       }
 
       process.exit(typeof res.code === "number" ? res.code : 0);
@@ -279,7 +299,7 @@ async function main() {
 
       const queueDir = getQueueDir(root);
       const files = readdirSync(queueDir).filter((f) => isTaskFile(f, queueDir));
-      console.log(`Found ${files.length} queued task(s) in .agent/queue/`);
+      console.log(`Found ${files.length} queued task(s) in .agent/jules-queue/`);
       if (files.length > 0) {
         const concurrency = values.concurrency ? Number(values.concurrency) : undefined;
         const results = await run(null, {
@@ -750,13 +770,47 @@ async function main() {
 
     case "rollback": {
       const { restoreCheckpoint } = await import("../src/ops/checkpoint.mjs");
-      const targetId = args[1] || "--latest";
+      const { createHandover } = await import("../src/ops/handover.mjs");
+      const { values, positionals } = parseArgs({
+        args: args.slice(1),
+        options: {
+          reason: { type: "string", short: "r" },
+          intent: { type: "string", short: "i" },
+          handover: { type: "boolean", default: true },
+          json: { type: "boolean", short: "j" },
+        },
+        allowPositionals: true,
+      });
+
+      const targetId = positionals[0] || "--latest";
       try {
         const res = restoreCheckpoint(targetId, { root });
-        console.log(`\n✅ Git Checkpoint Restored Successfully!`);
-        console.log(`   Session ID : ${res.id}`);
-        console.log(`   HEAD SHA   : ${res.headSha || "N/A"}`);
-        console.log(`   RestoredAt : ${res.restoredAt}\n`);
+        let hoResult = null;
+        if (values.handover !== false) {
+          try {
+            hoResult = createHandover(root, {
+              sessionId: res.id,
+              status: "rolled-back",
+              intent: values.intent || "Restored working tree to pre-flight checkpoint",
+              landmines: values.reason ? [values.reason] : ["Session cancelled or rolled back by operator"],
+              branch: res.branch,
+              headSha: res.headSha,
+            });
+          } catch (_) {}
+        }
+
+        if (values.json) {
+          console.log(JSON.stringify({ ok: true, ...res, handover: hoResult?.filePath }, null, 2));
+        } else {
+          console.log(`\n✅ Git Checkpoint Restored Successfully!`);
+          console.log(`   Session ID : ${res.id}`);
+          console.log(`   HEAD SHA   : ${res.headSha || "N/A"}`);
+          console.log(`   RestoredAt : ${res.restoredAt}`);
+          if (hoResult) {
+            console.log(`   Handover   : ${hoResult.filePath}`);
+          }
+          console.log("");
+        }
         process.exit(0);
       } catch (err) {
         console.error(`❌ Rollback Failed: ${err.message}`);
@@ -765,6 +819,122 @@ async function main() {
       break;
     }
 
+    case "handover": {
+      const {
+        createHandover,
+        loadHandover,
+        listHandovers,
+        pruneHandovers,
+        formatHandoverPromptContext,
+      } = await import("../src/ops/handover.mjs");
+
+      const subAction = args[1] || "list";
+      const { values, positionals } = parseArgs({
+        args: args.slice(2),
+        options: {
+          intent: { type: "string", short: "i" },
+          status: { type: "string", short: "s", default: "aborted" },
+          completed: { type: "string", short: "c" },
+          assumptions: { type: "string", short: "a" },
+          landmines: { type: "string", short: "l" },
+          "next-steps": { type: "string", short: "n" },
+          limit: { type: "string" },
+          json: { type: "boolean", short: "j" },
+          context: { type: "boolean" },
+        },
+        allowPositionals: true,
+      });
+
+      if (subAction === "list") {
+        let items = listHandovers(root);
+        const limitNum = parseInt(values.limit || "20", 10);
+        if (!isNaN(limitNum) && limitNum > 0) {
+          items = items.slice(0, limitNum);
+        }
+        if (values.json) {
+          console.log(JSON.stringify({ ok: true, count: items.length, handovers: items }, null, 2));
+        } else {
+          console.log(`\n📋 Baton Pass Handover Envelopes (${items.length})`);
+          console.log(`--------------------------------------------------`);
+          if (items.length === 0) {
+            console.log(`  (No handovers found in .agent/handovers/)`);
+          } else {
+            items.forEach((h, idx) => {
+              console.log(`  ${idx + 1}. [${h.status.toUpperCase()}] ${h.sessionId} (${h.createdAt.substring(0, 16)})`);
+              if (h.intent) console.log(`     Intent: ${h.intent.substring(0, 80)}`);
+              console.log(`     File  : ${h.filePath}\n`);
+            });
+          }
+          console.log(`--------------------------------------------------\n`);
+        }
+        process.exit(0);
+      }
+
+      if (subAction === "show") {
+        const targetId = positionals[0];
+        if (!targetId) {
+          console.error("Error: Session ID or file path is required for agentctl handover show <sessionId>");
+          process.exit(1);
+        }
+        try {
+          const ho = loadHandover(root, targetId);
+          if (values.context) {
+            console.log(formatHandoverPromptContext(ho));
+          } else if (values.json) {
+            console.log(JSON.stringify({ ok: true, handover: ho }, null, 2));
+          } else {
+            console.log(ho.rawMarkdown);
+          }
+          process.exit(0);
+        } catch (err) {
+          console.error(`❌ Error loading handover: ${err.message}`);
+          process.exit(1);
+        }
+      }
+
+      if (subAction === "create") {
+        const targetId = positionals[0] || `session-${Date.now()}`;
+        try {
+          const res = createHandover(root, {
+            sessionId: targetId,
+            status: values.status,
+            intent: values.intent,
+            completed: values.completed,
+            assumptions: values.assumptions,
+            landmines: values.landmines,
+            nextSteps: values["next-steps"],
+          });
+          if (values.json) {
+            console.log(JSON.stringify({ ok: true, ...res }, null, 2));
+          } else {
+            console.log(`\n✅ Handover Envelope Created Successfully!`);
+            console.log(`   Session ID : ${res.sessionId}`);
+            console.log(`   Status     : ${res.status}`);
+            console.log(`   File Path  : ${res.filePath}\n`);
+          }
+          process.exit(0);
+        } catch (err) {
+          console.error(`❌ Error creating handover: ${err.message}`);
+          process.exit(1);
+        }
+      }
+
+      if (subAction === "prune") {
+        const limitNum = parseInt(values.limit || "20", 10);
+        const count = pruneHandovers(root, limitNum);
+        if (values.json) {
+          console.log(JSON.stringify({ ok: true, pruned: count }, null, 2));
+        } else {
+          console.log(`✅ Pruned ${count} old handover manifest(s).`);
+        }
+        process.exit(0);
+      }
+
+      console.error(`Error: Unknown handover subcommand '${subAction}'. Use list, show, create, or prune.`);
+      process.exit(1);
+      break;
+    }
+
     case "resume": {
       const { createProvider } = await import("../src/provider.mjs");
       const sessionId = args[1];

package/bin/init.js

@@ -249,14 +249,14 @@ if (fs.existsSync(targetPkgPath) && targetDir !== kitRoot) {
     pkg.scripts = pkg.scripts || {};
     let updated = false;
     const julesScripts = {
-      "jules:dispatch": "npx agentctl dispatch",
-      "jules:queue": "npx agentctl queue",
-      "jules:create": "npx agentctl create",
-      "jules:status": "npx agentctl status",
-      "jules:audit": "npx agentctl gate",
-      "jules:scan": "npx agentctl scan",
-      "jules:swarm": "npx agentctl swarm",
-      "jules:nightly": "npx agentctl clean"
+      "jules:dispatch": "agentctl dispatch",
+      "jules:queue": "agentctl queue",
+      "jules:create": "agentctl task create",
+      "jules:status": "agentctl status",
+      "jules:audit": "agentctl gate",
+      "jules:scan": "agentctl scan",
+      "jules:swarm": "agentctl swarm",
+      "jules:nightly": "agentctl clean"
     };
 
     for (const [key, val] of Object.entries(julesScripts)) {

package/index.mjs

@@ -32,6 +32,7 @@ export {
   ProviderSchemaError,
   parseRetryAfter,
 } from "./src/provider.mjs";
+export { resolveRoutedProvider } from "./src/router.mjs";
 export {
   detectPolyglotStack,
   resolveWorkspaceBoundary,
@@ -71,8 +72,8 @@ export {
   verifyExecutionEnvelope,
   freezeExecutionEnvelope,
   hashExecutionEnvelope,
-} from "./src/execution_envelope.mjs";
-export { checkAssetIntegrity } from "./src/asset_integrity.mjs";
+} from "./src/execution-envelope.mjs";
+export { checkAssetIntegrity } from "./src/asset-integrity.mjs";
 export { classifyRiskTier, RISK_TIERS } from "./src/risk.mjs";
 export { recordRemediation, queryRemediations } from "./src/remediation.mjs";
 export { DagExecutor, DagCycleError } from "./src/dag-engine.mjs";
@@ -178,3 +179,14 @@ export {
   synthesizeFlakyHealingTask,
   runFlakyHealingSwarm,
 } from "./src/flaky-ledger.mjs";
+
+// Baton Pass Session Handover Engine
+export {
+  createHandover,
+  loadHandover,
+  listHandovers,
+  pruneHandovers,
+  formatHandoverPromptContext,
+  getHandoverDir,
+  HandoverError,
+} from "./src/ops/handover.mjs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jules-orchestrator-kit",
-  "version": "0.38.0",
+  "version": "0.38.2",
   "description": "Zero-dependency safety gatekeeper, test oracle generator, and multi-agent coordination protocol for Google Jules (jules) autonomous agents.",
   "repository": {
     "type": "git",

package/scripts/command-resolver.mjs

@@ -1,6 +1,5 @@
 /**
- * Backward compatibility shim for command-resolver.mjs in v0.9.0.
- * Re-exports detectStack from src/config.mjs.
+ * Project command resolver: infers build and test commands across stacks.
  */
 
 import { detectStack, parseYaml } from "../src/config.mjs";

package/scripts/doc-sync-check.mjs

@@ -53,7 +53,23 @@ export function parseTestCounts(out = "") {
     const m = String(out).match(new RegExp(`^[^\\n]*?(?:ℹ|#)\\s*${key}\\s+(\\d+)\\s*$`, "m"));
     return m ? Number(m[1]) : null;
   };
-  return { tests: num("tests"), pass: num("pass"), suites: num("suites"), todo: num("todo") };
+  // Names, not just a count. This gate runs where nobody is watching the
+  // output, and "2 failing" costs a round-trip through CI to turn into
+  // something actionable. The spec reporter prints each failure twice (inline
+  // and again in its summary), hence the dedupe.
+  const failures = [
+    ...String(out).matchAll(/^not ok \d+ - (.+?)$/gm),
+    ...String(out).matchAll(/^\s*✖\s+(.+?)\s+\(\d/gm),
+  ].map((m) => m[1].trim());
+
+  return {
+    tests: num("tests"),
+    pass: num("pass"),
+    suites: num("suites"),
+    todo: num("todo"),
+    fail: num("fail"),
+    failures: [...new Set(failures)],
+  };
 }
 
 function readIfExists(path) {
@@ -238,10 +254,29 @@ export function checkDocSync(root = process.cwd(), opts = {}) {
     const claimedSuites = claim ? Number(claim[2]) : null;
 
     let { tests, suites } = opts;
+    let measuredFail = null;
+    let measuredFailures = [];
     if (tests === undefined || suites === undefined) {
       const measured = measureTestCounts(root);
       tests = tests ?? measured.pass;
       suites = suites ?? measured.suites;
+      measuredFail = measured.fail;
+      measuredFailures = measured.failures || [];
+    }
+
+    // A failing suite still prints a summary, so the pass count silently drops
+    // and the README check reports a number mismatch — which reads as stale
+    // documentation and sends the reader looking for skipped tests. Say what
+    // actually happened instead. Only meaningful when this measured the suite
+    // itself; release.mjs passes counts in from a run it already verified.
+    if (measuredFail !== null) {
+      add(
+        "test suite passes",
+        measuredFail === 0,
+        measuredFail === 0
+          ? "no failing tests"
+          : `${measuredFail} failing: ${measuredFailures.slice(0, 3).join("; ") || "(names unparsed)"}${measuredFailures.length > 3 ? ` …+${measuredFailures.length - 3}` : ""}`
+      );
     }
 
     if (claimedTests === null) {

package/scripts/jules-create.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * Backward compatibility shim for jules-create.mjs in v0.9.0.
+ * Quick task file creator for .agent/jules-queue/.
  */
 
 import { writeFileSync } from "node:fs";

package/scripts/jules-dispatch.mjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * Backward compatibility shim for jules-dispatch.mjs in v0.9.1.
- * Delegates execution to bin/agentctl.mjs dispatch.
+ * Task dispatch entrypoint: delegates execution to engine dispatch pipeline.
  */
 
 import { dispatch } from "../src/engine.mjs";

package/scripts/jules-nightly.mjs

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 /**
- * Backward compatibility shim for jules-nightly.mjs in v0.9.0.
+ * Nightly repository maintenance and worktree pruning.
  */
 
 import { worktreePrune } from "../src/git.mjs";
 
 if (process.argv[1] && process.argv[1].endsWith("jules-nightly.mjs")) {
   worktreePrune();
-  console.log("[Shim] Nightly maintenance complete.");
+  console.log("Nightly maintenance complete.");
   process.exit(0);
 }

package/scripts/jules-patch.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * Backward compatibility shim for jules-patch.mjs in v0.9.0.
+ * Session patch fetching utility.
  */
 
 export async function fetchSessionPatch(sessionId, _options = {}) {
@@ -18,6 +18,6 @@ export async function fetchSessionPatch(sessionId, _options = {}) {
 }
 
 if (process.argv[1] && process.argv[1].endsWith("jules-patch.mjs")) {
-  console.log("[Shim] Patch fetch completed.");
+  console.log("Patch fetch completed.");
   process.exit(0);
 }

package/scripts/jules-queue-runner.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * Backward compatibility shim for jules-queue-runner.mjs in v0.9.0.
+ * Queue processing runner: processes envelopes in .agent/jules-queue/.
  */
 
 import { run } from "../src/engine.mjs";

package/scripts/jules-scan-todos.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * Backward compatibility shim for jules-scan-todos.mjs in v0.9.0.
+ * Codebase scanner for TODO and FIXME comments.
  */
 
 import { readdirSync, readFileSync, statSync } from "node:fs";

package/scripts/jules-self-audit.mjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * Backward compatibility shim for jules-self-audit.mjs in v0.9.0.
- * Delegates execution to src/engine.mjs gate().
+ * Self-audit gatekeeper: runs 4-phase safety gate against working tree or base branch.
  */
 
 import { existsSync } from "node:fs";

package/scripts/jules-status.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 /**
- * Backward compatibility shim for jules-status.mjs in v0.9.0.
+ * Session status and budget status summarizer.
  */
 
 import { checkDailyBudget } from "../src/state.mjs";

package/scripts/release.mjs

@@ -57,6 +57,61 @@ console.log("1b. Verifying documentation is in sync with package.json & test sui
   console.log("   ✅ Documentation is in sync.\n");
 }
 
+// 1c. Continuous-integration gate (blocking). Step 1 ran the suite on this one
+//     machine. Every cross-platform break this repository has shipped was green
+//     locally and red on the matrix — a forward-slash path assertion, a
+//     case-folded deny rule — so a local pass says nothing about Windows or
+//     macOS. `gh` resolves the repository from the git remote, so this is not
+//     specific to any one fork.
+console.log("1c. Verifying CI is green for HEAD...");
+if (process.argv.includes("--skip-ci-check")) {
+  console.log("   ⚠️ Skipped via --skip-ci-check.\n");
+} else {
+  const headSha = execSync("git rev-parse HEAD", { cwd: root, encoding: "utf-8" }).trim();
+  let runs;
+  try {
+    const raw = execSync("gh run list --limit 40 --json headSha,status,conclusion,workflowName,url", {
+      cwd: root,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "pipe"],
+    });
+    runs = JSON.parse(raw).filter((r) => r.headSha === headSha);
+  } catch {
+    console.error("❌ Release Aborted: could not query CI status via `gh`.");
+    console.error("   Run `gh auth login`, or re-run with --skip-ci-check to release without it.");
+    process.exit(1);
+  }
+
+  if (runs.length === 0) {
+    console.error(`❌ Release Aborted: no CI run found for HEAD (${headSha.slice(0, 7)}).`);
+    console.error("   Push the commit and let CI finish first, or re-run with --skip-ci-check.");
+    process.exit(1);
+  }
+
+  // A run that is still going is not a pass. Releasing on a pending matrix is
+  // exactly how a red Windows job gets published.
+  const pending = runs.filter((r) => r.status !== "completed");
+  const failed = runs.filter((r) => !["success", "skipped", "neutral"].includes(r.conclusion));
+
+  for (const r of runs) {
+    const state = r.status !== "completed" ? r.status : r.conclusion;
+    const mark = pending.includes(r) ? "⏳" : failed.includes(r) ? "❌" : "✅";
+    console.log(`   ${mark} ${r.workflowName.padEnd(32)} ${state}`);
+  }
+
+  if (pending.length > 0) {
+    console.error(`\n❌ Release Aborted: ${pending.length} CI run(s) still in progress for HEAD.`);
+    console.error(`   Wait for them to finish: ${pending[0].url}`);
+    process.exit(1);
+  }
+  if (failed.length > 0) {
+    console.error(`\n❌ Release Aborted: ${failed.length} CI run(s) not green for HEAD.`);
+    for (const r of failed) console.error(`   ${r.workflowName}: ${r.conclusion} — ${r.url}`);
+    process.exit(1);
+  }
+  console.log(`   ✅ All ${runs.length} CI run(s) green for ${headSha.slice(0, 7)}.\n`);
+}
+
 // 2. Extract release notes from CHANGELOG.md
 console.log(`2. Extracting release notes for ${tagName} from CHANGELOG.md...`);
 let notes = "";

package/scripts/run-tests.mjs

@@ -10,7 +10,21 @@ const testFiles = readdirSync(testDir)
   .sort()
   .map((f) => join("test", f));
 
-const res = spawnSync(process.execPath, ["--test", ...testFiles], {
+// A hung test has to fail, not stall. The readKeypresses() stdin regression
+// failed by hanging rather than throwing: without a per-test deadline that
+// burns a CI job to GitHub's six-hour default instead of going red in
+// seconds. The slowest genuine test on the Windows runner is ~2s, so this is
+// two orders of magnitude of headroom and only ever fires on a real hang.
+const timeoutMs = Number(process.env.JULES_TEST_TIMEOUT_MS) || 60_000;
+
+// `--test-timeout` landed in Node 20.6. package.json engines allows >=20.0.0,
+// and an unrecognised flag makes Node abort before running anything — so on an
+// older runtime the suite runs without the deadline rather than not at all.
+const [major, minor] = process.versions.node.split(".").map(Number);
+const supportsTestTimeout = major > 20 || (major === 20 && minor >= 6);
+const timeoutArgs = supportsTestTimeout ? [`--test-timeout=${timeoutMs}`] : [];
+
+const res = spawnSync(process.execPath, ["--test", ...timeoutArgs, ...testFiles], {
   cwd: root,
   stdio: "inherit",
   env: process.env,

package/scripts/utils.mjs

@@ -1,13 +1,13 @@
 /**
- * Backward compatibility shim for utils.mjs in v0.9.0.
- * Re-exports utilities from modular src/ domain modules.
+ * 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 } from "../src/state.mjs";
+import { appendLedger, checkDailyBudget as baseCheckDailyBudget, verifyLedgerIntegrity as baseVerifyLedgerIntegrity } from "../src/state.mjs";
 
 export { loadConfig, resolveRoot, normalizePath } from "../src/config.mjs";
 export {
@@ -45,7 +45,7 @@ export function loadEnv(targetDir = process.cwd()) {
   if (!existsSync(envPath)) return;
   try {
     const raw = readFileSync(envPath, "utf-8");
-    for (const line of raw.split("\n")) {
+    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;
@@ -79,7 +79,7 @@ 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 { writeFileSync(historyDir, ""); } catch (_) {}
+    try { mkdirSync(historyDir, { recursive: true }); } catch (_) {}
   }
   const filePath = join(historyDir, `${dateStr}-${filename}`);
   try { writeFileSync(filePath, content, "utf-8"); } catch (_) {}
@@ -145,7 +145,7 @@ export function reserveDailyBudget(maxSessions = 300, taskKey = "", root = resol
   // 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()}-${Math.random().toString(36).substring(2, 8)}`;
+  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 };
@@ -155,12 +155,17 @@ 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) {
-      JSON.parse(line);
+      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 (_) {
-    return { ok: false, count: 0, error: "Invalid JSON in ledger" };
+  } catch (err) {
+    return { ok: false, count: 0, error: err.message || "Invalid JSON in ledger" };
   }
 }