jules-orchestrator-kit 0.72.2 → 0.73.0

package/src/engine.mjs

@@ -13,7 +13,7 @@ import { recordVerifyRun, readVerifyRuns, flakyVerdict } from "./flaky-ledger.mj
 import fs, { readdirSync, readFileSync, renameSync, existsSync } from "node:fs";
 import { join, basename } from "node:path";
 import { createHash } from "node:crypto";
-import { appendTelemetry as appendTelemetryUnsafe } from "./telemetry.mjs";
+import { appendTelemetryBestEffort as appendTelemetry } from "./telemetry.mjs";
 
 import { spawn } from "node:child_process";
 import { resolveAffectedTests, executeQueueDag } from "./dag-engine.mjs";
@@ -59,14 +59,6 @@ export {
 };
 
 
-function appendTelemetry(root, kind, fields = {}) {
-  try {
-    return appendTelemetryUnsafe(root, kind, fields);
-  } catch (_) {
-    return null;
-  }
-}
-
 function isSafeQueueFileName(fileName) {
   return typeof fileName === "string" && fileName.length > 0 && basename(fileName) === fileName && fileName !== "." && fileName !== "..";
 }
@@ -1138,8 +1130,8 @@ function buildRepairPrompt(failure, attempt, _config, extraPromptDirective = nul
   let escalationDirective = "1. Ground your fix strictly in the error log below. Do NOT guess file contents or function signatures.";
 
   if (extraPromptDirective) {
-    escalationStrategy = "WHACK_A_MOLE_PIVOT";
-    escalationDirective = `1. ARCHITECTURAL PIVOT: ${extraPromptDirective}`;
+    escalationStrategy = "Test Oscillation Circuit Breaker Activated";
+    escalationDirective = `1. Switching verification strategy: ${extraPromptDirective}`;
   } else if (attempt === 2) {
     escalationStrategy = "DIAGNOSTIC_ANALYSIS";
     escalationDirective = "1. DIAGNOSE FIRST: Two attempts have failed. Analyze if the root cause is in a different file or component than where the previous patch was applied.";
@@ -1205,10 +1197,15 @@ export async function dispatch(task = {}, opts = {}) {
   let cleanPrompt = redactSecrets(task.prompt || "");
 
   // Specialist Role resolution (if role is set and not already present in prompt)
-  if (task.role && !cleanPrompt.includes("Protocol - ")) {
-    const roleObj = resolveRolePrompt(root, task.role);
+  if (task.role) {
+    const roleObj = resolveRolePrompt(root, task.role, { config });
     if (roleObj) {
-      cleanPrompt = `${roleObj.content}\n\n${cleanPrompt}`.trim();
+      const alreadyHasRole = cleanPrompt.includes(roleObj.content.slice(0, 60)) ||
+        cleanPrompt.includes(`# ${roleObj.role}`) ||
+        cleanPrompt.includes("Protocol - ");
+      if (!alreadyHasRole) {
+        cleanPrompt = `${roleObj.content}\n\n${cleanPrompt}`.trim();
+      }
     } else {
       // A role reaching here comes from a task envelope or an internal
       // synthesis rather than a typed flag, so the dispatch still proceeds with
@@ -1227,7 +1224,13 @@ export async function dispatch(task = {}, opts = {}) {
   }
 
   // Wire Prompt Guard, Memory Hydration & Envelope to wrap raw task arguments
-  const taskInstructions = task.taskInstructions || cleanPrompt || task.title || "Autonomous Task Execution";
+  let taskInstructions = cleanPrompt;
+  if (task.taskInstructions && task.taskInstructions !== cleanPrompt) {
+    taskInstructions = cleanPrompt ? `${cleanPrompt}\n\n${task.taskInstructions}` : task.taskInstructions;
+  }
+  if (!taskInstructions) {
+    taskInstructions = task.title || "Autonomous Task Execution";
+  }
   const untrustedData = Array.isArray(task.untrustedData) ? task.untrustedData : [];
   const systemPolicy = task.systemPolicy || config.systemPolicy || "";
 
@@ -1236,6 +1239,11 @@ export async function dispatch(task = {}, opts = {}) {
 
   const envelopedPrompt = buildAgentEnvelope(systemPolicy, taskInstructions, untrustedData, { learnedRemediations });
 
+  // Enforce prompt size limit on the assembled final payload
+  if (Buffer.byteLength(envelopedPrompt, "utf-8") > promptKb) {
+    throw new Error(`Task prompt exceeds maximum payload limit of ${config.limits.promptKb} KB (${Math.ceil(Buffer.byteLength(envelopedPrompt, "utf-8") / 1024)} KB)`);
+  }
+
   const cleanTask = { ...task, prompt: envelopedPrompt };
 
   // Snapshot the tree before anything can change it.
@@ -1606,4 +1614,20 @@ export async function probeDevServer(serverConfig = {}, root = process.cwd()) {
   }
 }
 
-
+/**
+ * Classify a queue-run failure as "concurrency_limit" (retry later without
+ * consuming a fresh dispatch) or "retriable".
+ *
+ * Moved out of scripts/jules-queue-runner.mjs, which keeps only the process
+ * entry point; the queue loop itself already lives in this module.
+ *
+ * @param {Error|string} err
+ * @returns {"concurrency_limit" | "retriable"}
+ */
+export function classifyQueueFailure(err) {
+  const msg = String(err?.message || err || "");
+  if (msg.includes("FAILED_PRECONDITION") || msg.includes("Active Session Limit") || msg.includes("concurrency")) {
+    return "concurrency_limit";
+  }
+  return "retriable";
+}

package/src/evidence.mjs

@@ -4,26 +4,19 @@ import {
   existsSync,
   readdirSync,
   statSync,
-  openSync,
-  writeSync,
-  fsyncSync,
-  closeSync,
-  renameSync,
   unlinkSync,
 } from "node:fs";
-import { join, resolve, relative, isAbsolute, sep, extname } from "node:path";
+import { join, resolve, relative, isAbsolute, extname } from "node:path";
 import { createHash, randomUUID } from "node:crypto";
 import { execSync } from "node:child_process";
 import { isTestPath } from "./test-paths.mjs";
+import { safeAtomicWrite } from "./security.mjs";
+import { normalizePath } from "./config.mjs";
 
-/**
- * Normalizes file path to POSIX slashes.
- * @param {string} p
- * @returns {string}
- */
-export function normalizePath(p = "") {
-  return p.split(sep).join("/").replace(/\\/g, "/");
-}
+// normalizePath is the single shared implementation in src/config.mjs (the
+// copy that used to live here differed only by not guarding non-strings).
+// Re-exported so `./evidence.mjs` callers keep the same entry point.
+export { normalizePath };
 
 /**
  * Computes SHA-256 hex digest of a string or buffer.
@@ -232,30 +225,6 @@ export function computeEvidenceHash(manifest) {
   return "sha256:" + sha256(canonicalPayload);
 }
 
-/**
- * Safely writes a file atomically.
- * @param {string} filePath
- * @param {string} content
- */
-function writeFileAtomically(filePath, content) {
-  const tmpPath = `${filePath}.${randomUUID()}.tmp`;
-  let fd;
-  try {
-    fd = openSync(tmpPath, "wx", 0o600);
-    writeSync(fd, content, "utf-8");
-    fsyncSync(fd);
-    closeSync(fd);
-    fd = undefined;
-    renameSync(tmpPath, filePath);
-  } catch (err) {
-    if (fd !== undefined) {
-      try { closeSync(fd); } catch (_) {}
-    }
-    try { unlinkSync(tmpPath); } catch (_) {}
-    throw err;
-  }
-}
-
 /**
  * Queries current git provenance data safely.
  * @param {string} root
@@ -407,12 +376,12 @@ export function writeEvidenceManifest(root, manifest, customPath = null) {
     ? isAbsolute(customPath) ? customPath : join(root, customPath)
     : join(evidenceDir, `${manifest.manifestId}.json`);
 
-  writeFileAtomically(targetPath, JSON.stringify(manifest, null, 2));
+  safeAtomicWrite(targetPath, JSON.stringify(manifest, null, 2), { mode: 0o600 });
 
   // Also maintain symlink/latest pointer
   const latestPath = join(evidenceDir, "manifest.v1.json");
   try {
-    writeFileAtomically(latestPath, JSON.stringify(manifest, null, 2));
+    safeAtomicWrite(latestPath, JSON.stringify(manifest, null, 2), { mode: 0o600 });
   } catch (_) {}
 
   // Written at a custom path means the caller owns the location and its
@@ -612,7 +581,7 @@ export function exportJsonReport(manifest, customPath = null) {
   };
 
   if (customPath) {
-    writeFileAtomically(customPath, JSON.stringify(report, null, 2));
+    safeAtomicWrite(customPath, JSON.stringify(report, null, 2), { mode: 0o600 });
   }
 
   return report;

package/src/execution-envelope.mjs

@@ -33,6 +33,18 @@ export function hashExecutionEnvelope(envelope) {
   return createHash("sha256").update(JSON.stringify(canonicalPayload)).digest("hex");
 }
 
+/**
+ * Hashes the envelope's scope triple. The configSha contract: SHA-256 over
+ * exactly `{ denyPaths, allowPaths, protectPaths }`, defined once here so the
+ * implementation cannot drift from the specification.
+ *
+ * @param {{ denyPaths?: string[], allowPaths?: string[], protectPaths?: string[] }} scope
+ * @returns {string} Hex SHA-256 digest.
+ */
+export function hashConfigScope({ denyPaths = [], allowPaths = [], protectPaths = [] } = {}) {
+  return createHash("sha256").update(JSON.stringify({ denyPaths, allowPaths, protectPaths })).digest("hex");
+}
+
 /**
  * Deep freezes an execution envelope to prevent modifications during OODA repair loops.
  */
@@ -93,7 +105,7 @@ export function createExecutionEnvelope(task = {}, opts = {}) {
     taskId,
     baseRef,
     baseSha,
-    configSha: createHash("sha256").update(JSON.stringify({ denyPaths, allowPaths, protectPaths })).digest("hex"),
+    configSha: hashConfigScope({ denyPaths, allowPaths, protectPaths }),
     scope: {
       deny: denyPaths,
       allow: allowPaths,

package/src/flaky-ledger.mjs

@@ -250,7 +250,7 @@ export function synthesizeFlakyHealingTask(quarantinedItem, options = {}) {
   // in a non-Node repo it produced a healing task that could not run.
   const testCmd = item.testCmd || options.testCmd || options.config?.verify?.test || "";
   const oscillationPct = Math.round((item.oscillation || 0.4) * 100);
-  const role = options.role || "janitor";
+  const role = options.role || "hygiene";
   const slug = String(testCmd).replace(/[^a-zA-Z0-9]/g, "-").replace(/-+/g, "-").slice(0, 20).toLowerCase();
   const taskId = options.taskId || `flaky-heal-${slug}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
 

package/src/fs-atomic.mjs

@@ -0,0 +1,72 @@
+/**
+ * Atomic filesystem writes for the kit's own state.
+ *
+ * Split out of src/security.mjs (P05): these are the write primitives every
+ * durable artefact in the kit rests on — a state file, an evidence bundle, a
+ * handover — and they have nothing to do with scanning a diff. They sit at the
+ * bottom of the dependency graph on purpose: nothing under src/ needs to import
+ * security scanning in order to write a file safely.
+ *
+ * Relocation only; the logic, the failure modes and the comment reasoning are
+ * the originals.
+ */
+
+import { openSync, writeSync, fsyncSync, closeSync, renameSync, realpathSync, existsSync, lstatSync, unlinkSync } from "node:fs";
+import { dirname, join, basename } from "node:path";
+import { randomBytes } from "node:crypto";
+
+export function safeRenameSync(src, dst) {
+  try {
+    renameSync(src, dst);
+  } catch (err) {
+    if (process.platform === "win32" && (err.code === "EEXIST" || err.code === "EPERM")) {
+      try { unlinkSync(dst); } catch (_) {}
+      renameSync(src, dst);
+    } else {
+      throw err;
+    }
+  }
+}
+
+/**
+ * TOCTOU-safe atomic file write using O_CREAT|O_EXCL|O_WRONLY temp file in target dir.
+ */
+export function safeAtomicWrite(filePath, content, options = {}) {
+  const mode = options.mode || 0o644;
+  const encoding = options.encoding || "utf-8";
+  const rejectSymlinks = options.rejectSymlinks !== false;
+
+  if (existsSync(filePath)) {
+    const stat = lstatSync(filePath);
+    if (stat.isSymbolicLink()) {
+      const realPath = realpathSync(filePath);
+      if (rejectSymlinks) {
+        throw new Error(`TOCTOU Guard: Refusing to write to symlink ${filePath} -> ${realPath}`);
+      }
+    }
+  }
+
+  const dir = dirname(filePath);
+  const tempFile = join(dir, `.tmp-${basename(filePath)}-${randomBytes(6).toString("hex")}`);
+
+  let fd;
+  try {
+    fd = openSync(tempFile, "wx", mode);
+    writeSync(fd, content, null, encoding);
+    if (options.sync !== false) {
+      fsyncSync(fd);
+    }
+    closeSync(fd);
+    fd = undefined;
+    safeRenameSync(tempFile, filePath);
+    return true;
+  } catch (err) {
+    if (fd !== undefined) {
+      try { closeSync(fd); } catch (_) {}
+    }
+    try {
+      if (existsSync(tempFile)) unlinkSync(tempFile);
+    } catch (_) {}
+    throw err;
+  }
+}