jules-orchestrator-kit 0.38.0 → 0.38.2

package/src/asset-integrity.mjs

@@ -0,0 +1,76 @@
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import { join, extname } from "node:path";
+
+const BINARY_EXTENSIONS = new Set([
+  ".woff2", ".woff", ".ttf", ".otf", ".eot",
+  ".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif",
+  ".pdf", ".ico"
+]);
+
+/**
+ * Checks binary and font assets for silent HTML/text corruption (e.g. fake font saved HTML error page).
+ *
+ * @param {string} searchDir - Directory to scan (e.g., public/ or src/assets/)
+ * @returns {{ ok: boolean, checkedCount: number, corruptedFiles: Array<{ path: string, reason: string }> }}
+ */
+export function checkAssetIntegrity(searchDir) {
+  const corruptedFiles = [];
+  let checkedCount = 0;
+
+  function scan(dir) {
+    let entries = [];
+    try {
+      entries = readdirSync(dir);
+    } catch (_) {
+      return;
+    }
+
+    for (const entry of entries) {
+      if (entry.startsWith(".") || entry === "node_modules") continue;
+      const fullPath = join(dir, entry);
+      let stat;
+      try {
+        stat = statSync(fullPath);
+      } catch (_) {
+        continue;
+      }
+
+      if (stat.isDirectory()) {
+        scan(fullPath);
+      } else if (stat.isFile()) {
+        const ext = extname(entry).toLowerCase();
+        if (BINARY_EXTENSIONS.has(ext)) {
+          checkedCount++;
+          try {
+            // Read first 64 bytes
+            const fd = readFileSync(fullPath);
+            const header = fd.subarray(0, 64).toString("utf-8").toLowerCase().trim();
+
+            if (
+              header.startsWith("<!doctype") ||
+              header.startsWith("<html") ||
+              header.startsWith("<?xml") ||
+              header.startsWith("{\"error") ||
+              header.startsWith("{\"status")
+            ) {
+              corruptedFiles.push({
+                path: fullPath,
+                reason: `File has extension '${ext}' but starts with text header '${header.substring(0, 20)}'`,
+              });
+            }
+          } catch (_) {
+            // Ignore read errors
+          }
+        }
+      }
+    }
+  }
+
+  scan(searchDir);
+
+  return {
+    ok: corruptedFiles.length === 0,
+    checkedCount,
+    corruptedFiles,
+  };
+}

package/src/asset_integrity.mjs

@@ -1,76 +1 @@
-import { readFileSync, readdirSync, statSync } from "node:fs";
-import { join, extname } from "node:path";
-
-const BINARY_EXTENSIONS = new Set([
-  ".woff2", ".woff", ".ttf", ".otf", ".eot",
-  ".png", ".jpg", ".jpeg", ".gif", ".webp", ".avif",
-  ".pdf", ".ico"
-]);
-
-/**
- * Checks binary and font assets for silent HTML/text corruption (e.g. fake font saved HTML error page).
- *
- * @param {string} searchDir - Directory to scan (e.g., public/ or src/assets/)
- * @returns {{ ok: boolean, checkedCount: number, corruptedFiles: Array<{ path: string, reason: string }> }}
- */
-export function checkAssetIntegrity(searchDir) {
-  const corruptedFiles = [];
-  let checkedCount = 0;
-
-  function scan(dir) {
-    let entries = [];
-    try {
-      entries = readdirSync(dir);
-    } catch (_) {
-      return;
-    }
-
-    for (const entry of entries) {
-      if (entry.startsWith(".") || entry === "node_modules") continue;
-      const fullPath = join(dir, entry);
-      let stat;
-      try {
-        stat = statSync(fullPath);
-      } catch (_) {
-        continue;
-      }
-
-      if (stat.isDirectory()) {
-        scan(fullPath);
-      } else if (stat.isFile()) {
-        const ext = extname(entry).toLowerCase();
-        if (BINARY_EXTENSIONS.has(ext)) {
-          checkedCount++;
-          try {
-            // Read first 64 bytes
-            const fd = readFileSync(fullPath);
-            const header = fd.subarray(0, 64).toString("utf-8").toLowerCase().trim();
-
-            if (
-              header.startsWith("<!doctype") ||
-              header.startsWith("<html") ||
-              header.startsWith("<?xml") ||
-              header.startsWith("{\"error") ||
-              header.startsWith("{\"status")
-            ) {
-              corruptedFiles.push({
-                path: fullPath,
-                reason: `File has extension '${ext}' but starts with text header '${header.substring(0, 20)}'`,
-              });
-            }
-          } catch (_) {
-            // Ignore read errors
-          }
-        }
-      }
-    }
-  }
-
-  scan(searchDir);
-
-  return {
-    ok: corruptedFiles.length === 0,
-    checkedCount,
-    corruptedFiles,
-  };
-}
+export * from "./asset-integrity.mjs";

package/src/config.mjs

@@ -43,11 +43,22 @@ export const BUILTIN_DENY = [
 
 export const BUILTIN_PROTECT = [
   ".agent/rules/**",
+  ".agent/SYSTEM_LEARNINGS.md",
+  ".agent/knowledge/**",
   "package.json",
+  "**/package.json",
   "Cargo.toml",
+  "**/Cargo.toml",
   "pyproject.toml",
+  "**/pyproject.toml",
   "go.mod",
+  "**/go.mod",
+  "composer.json",
+  "**/composer.json",
   "Makefile",
+  "**/Makefile",
+  "**/.npmrc",
+  "**/.netrc",
 ];
 
 const BLOCKED_KEYS = new Set(["__proto__", "constructor", "prototype"]);
@@ -383,22 +394,24 @@ export function loadConfig(root = resolveRoot(), explicitPath = null) {
     }
   }
 
-  const setupCmd = parsed.setup_cmd || parsed.verify?.setup || "";
-  const testCmd = parsed.test_cmd || parsed.verify?.test || "";
-  const lintCmd = parsed.lint_cmd || parsed.verify?.lint || "";
-  const fuzzCmd = parsed.fuzz_cmd || parsed.verify?.fuzz || "";
-  const invariantCmd = parsed.invariant_cmd || parsed.verify?.invariant || "";
-  const e2eCmd = parsed.e2e_cmd || parsed.verify?.e2e || "";
-  const teardownCmd = parsed.teardown_cmd || parsed.verify?.teardown || "";
-  const buildCmd = parsed.build_cmd || parsed.verify?.build || "";
+  const rawSetup = parsed.setup_cmd ?? parsed.verify?.setup;
+  const rawTest = parsed.test_cmd ?? parsed.verify?.test;
+  const rawLint = parsed.lint_cmd ?? parsed.verify?.lint;
+  const rawFuzz = parsed.fuzz_cmd ?? parsed.verify?.fuzz;
+  const rawInvariant = parsed.invariant_cmd ?? parsed.verify?.invariant;
+  const rawE2e = parsed.e2e_cmd ?? parsed.verify?.e2e;
+  const rawTeardown = parsed.teardown_cmd ?? parsed.verify?.teardown;
+  const rawBuild = parsed.build_cmd ?? parsed.verify?.build;
+  const rawUnit = parsed.verify?.unit;
   const verifyTimeoutMs = parsed.verify?.timeoutMs ?? parsed.verify?.timeout_ms ?? 60000;
   const autoVerify = resolveVerify(root);
 
-  const activeTier = String(process.env.JULES_TIER || parsed.tier || "ultra").toLowerCase();
-  const tierLimits = TIER_PRESETS[activeTier] || TIER_PRESETS.ultra;
+  const rawTier = String(process.env.JULES_TIER || parsed.tier || "ultra").toLowerCase();
+  const activeTier = TIER_PRESETS[rawTier] ? rawTier : "ultra";
+  const tierLimits = TIER_PRESETS[activeTier];
 
-  const envDailyTasks = process.env.JULES_DAILY_BUDGET !== undefined ? Number(process.env.JULES_DAILY_BUDGET) : null;
-  const envDiffKb = process.env.JULES_MAX_DIFF_KB !== undefined ? Number(process.env.JULES_MAX_DIFF_KB) : null;
+  const envDailyTasks = process.env.JULES_DAILY_BUDGET !== undefined && Number.isFinite(Number(process.env.JULES_DAILY_BUDGET)) ? Number(process.env.JULES_DAILY_BUDGET) : null;
+  const envDiffKb = process.env.JULES_MAX_DIFF_KB !== undefined && Number.isFinite(Number(process.env.JULES_MAX_DIFF_KB)) ? Number(process.env.JULES_MAX_DIFF_KB) : null;
 
   const parsedLimits = parsed.limits || {};
   const normalizedLimits = {
@@ -418,17 +431,17 @@ export function loadConfig(root = resolveRoot(), explicitPath = null) {
     provider: parsed.provider || DEFAULTS.provider,
     tier: activeTier,
     verify: {
-      setup: setupCmd || autoVerify.setup || "",
-      lint: lintCmd || autoVerify.lint || "",
-      test: testCmd || autoVerify.test,
-      unit: parsed.verify?.unit || testCmd || autoVerify.unit || autoVerify.test,
-      fuzz: fuzzCmd || autoVerify.fuzz || "",
-      invariant: invariantCmd || autoVerify.invariant || "",
-      e2e: e2eCmd || autoVerify.e2e || "",
-      teardown: teardownCmd || autoVerify.teardown || "",
-      build: buildCmd || autoVerify.build,
-      stages: parsed.verify?.stages || autoVerify.stages || null,
-      policy: parsed.verify?.policy || autoVerify.policy,
+      setup: rawSetup ?? autoVerify.setup ?? "",
+      lint: rawLint ?? autoVerify.lint ?? "",
+      test: rawTest ?? autoVerify.test,
+      unit: rawUnit ?? rawTest ?? autoVerify.unit ?? autoVerify.test,
+      fuzz: rawFuzz ?? autoVerify.fuzz ?? "",
+      invariant: rawInvariant ?? autoVerify.invariant ?? "",
+      e2e: rawE2e ?? autoVerify.e2e ?? "",
+      teardown: rawTeardown ?? autoVerify.teardown ?? "",
+      build: rawBuild ?? autoVerify.build,
+      stages: parsed.verify?.stages ?? autoVerify.stages ?? null,
+      policy: parsed.verify?.policy ?? autoVerify.policy,
       timeoutMs: Number.isFinite(Number(verifyTimeoutMs)) ? Number(verifyTimeoutMs) : 60000,
     },
     evidence: {
@@ -481,6 +494,12 @@ export function loadConfig(root = resolveRoot(), explicitPath = null) {
     runner: parsed.runner || DEFAULTS.runner,
     branchPrefix: parsed.branch_prefix || parsed.branchPrefix || DEFAULTS.branchPrefix,
     baseBranch: parsed.base_branch || parsed.baseBranch || DEFAULTS.baseBranch,
+    julesApiKeys: Array.from(new Set([
+      (process.env.JULES_API_KEY || "").trim(),
+      ...(process.env.JULES_API_KEYS || process.env.JULES_API_KEY_SECONDARY || "").split(",").map((k) => k.trim()),
+      ...(Array.isArray(parsed.jules_api_keys) ? parsed.jules_api_keys : []),
+      ...(Array.isArray(parsed.julesApiKeys) ? parsed.julesApiKeys : []),
+    ].filter(Boolean))),
     _root: root,
     _file: configFile || null,
   };

package/src/dag-engine.mjs

@@ -417,9 +417,42 @@ export function resolveAffectedTests(modifiedFiles = [], options = {}) {
  * @param {Object} [options.config]
  * @returns {Promise<{ processed: number, results: Array<any> }>}
  */
+/**
+ * Decides whether a queue-directory entry is a task this runner should execute.
+ *
+ * The DAG runner accepts more shapes than `isTaskFile` does — `.json` and
+ * `.task` envelopes as well as Markdown — but "every `.json` in the queue
+ * folder" also swept up manifests (swarm run files, indexes). A manifest has no
+ * `prompt`, so the whole file became the prompt and a large one blew the
+ * provider payload limit. Shape decides, not the extension.
+ *
+ * @param {string} fileName
+ * @param {string} content
+ * @param {Function} isTaskFile - `isTaskFile` from engine.mjs, passed in to avoid a circular import.
+ * @returns {boolean}
+ */
+function isDagTaskFile(fileName, content, isTaskFile) {
+  if (fileName.endsWith(".task")) return true;
+  if (fileName.endsWith(".md")) return isTaskFile(fileName, content);
+  if (fileName.endsWith(".json")) {
+    let parsed;
+    try {
+      parsed = JSON.parse(content);
+    } catch (_) {
+      return false;
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return false;
+    // A manifest *describes* tasks; a task envelope *is* one.
+    if (Array.isArray(parsed.tasks) || Array.isArray(parsed.envelopes)) return false;
+    return typeof parsed.prompt === "string" && parsed.prompt.length > 0;
+  }
+  return false;
+}
+
 export async function executeQueueDag(root = process.cwd(), options = {}) {
   const { readdirSync, renameSync, mkdirSync } = await import("node:fs");
   const { join, basename } = await import("node:path");
+  const { isTaskFile } = await import("./engine.mjs");
 
   const queueDir = join(root, ".agent", "jules-queue");
   const fallbackQueueDir = join(root, ".agent", "queue");
@@ -429,7 +462,7 @@ export async function executeQueueDag(root = process.cwd(), options = {}) {
   if (!existsSync(actualQueueDir)) {
     return { processed: 0, results: [] };
   }
-  if (!existsSync(completedDir)) {
+  if (!existsSync(completedDir) && !options.dryRun) {
     try {
       mkdirSync(completedDir, { recursive: true });
     } catch (_) {}
@@ -452,6 +485,7 @@ export async function executeQueueDag(root = process.cwd(), options = {}) {
     if (basename(file) !== file) continue;
     const fullPath = join(actualQueueDir, file);
     const content = readFileSync(fullPath, "utf-8");
+    if (!isDagTaskFile(file, content, isTaskFile)) continue;
     let taskId = file.replace(/\.(md|json|task)$/, "");
     let dependsOn = [];
     let title = taskId;
@@ -508,13 +542,17 @@ export async function executeQueueDag(root = process.cwd(), options = {}) {
           results.push({ file: t.file, taskId: t.taskId, ok: false, status: session.status, error: session.error, session });
           throw new Error(`DAG Task '${t.taskId}' failed: ${session.error || session.status || "Unknown error"}`);
         } else {
-          const dstPath = join(completedDir, t.file);
-          if (existsSync(srcPath)) {
-            if (!existsSync(dstPath)) {
-              renameSync(srcPath, dstPath);
+          // A dry run simulates; it must leave the queue exactly as it found it,
+          // or the second `--dry-run` sees an empty queue.
+          if (!options.dryRun) {
+            const dstPath = join(completedDir, t.file);
+            if (existsSync(srcPath)) {
+              if (!existsSync(dstPath)) {
+                renameSync(srcPath, dstPath);
+              }
             }
           }
-          results.push({ file: t.file, taskId: t.taskId, ok: true, session });
+          results.push({ file: t.file, taskId: t.taskId, ok: true, dryRun: Boolean(options.dryRun), session });
         }
       },
     });

package/src/engine.mjs

@@ -16,7 +16,7 @@ import { spawn } from "node:child_process";
 import { resolveAffectedTests, executeQueueDag } from "./dag-engine.mjs";
 import { recordRemediation, queryRemediations, harvestFailureRecord, hydrateMemory } from "./remediation.mjs";
 import { hydratePrompt, harvestFailure } from "./memory.mjs";
-import { resolveRolePrompt } from "./wizard-task.mjs";
+import { resolveRolePrompt } from "./role-resolver.mjs";
 
 import {
   computeDirectoryHash,
@@ -824,7 +824,7 @@ export async function run(tasksOrOpts = {}, opts = {}) {
 
   const queueDir = getQueueDir(root);
   const completedDir = join(queueDir, "completed");
-  ensureDir(completedDir);
+  if (!isDry) ensureDir(completedDir);
 
   let filesToProcess = [];
   if (Array.isArray(tasks)) {
@@ -858,10 +858,17 @@ export async function run(tasksOrOpts = {}, opts = {}) {
             return;
           }
 
-          const session = await dispatch(task, { root, config, dryRun: isDry });
+          // options.provider mirrors dispatch()'s existing injection point so a
+          // caller can exercise the real queue lifecycle without a live provider.
+          const session = await dispatch(task, { root, config, dryRun: isDry, provider: options.provider });
 
           if (session && session.ok === false) {
             results.push({ file: fileName, ok: false, status: session.status, error: session.error, session });
+          } else if (isDry) {
+            // A dry run simulates; it must leave the queue exactly as it found
+            // it, or the second `--dry-run` sees an empty queue. Nothing
+            // completed either, so nothing is written to the ledger.
+            results.push({ file: fileName, ok: true, dryRun: true, session });
           } else {
             const dstPath = join(completedDir, fileName);
             if (existsSync(srcPath)) {
@@ -908,31 +915,31 @@ export function synthesizePrDescription(session = {}, gateResult = {}, options =
   const kbLimit = ((payloadPhase.limitBytes || 76800) / 1024).toFixed(0);
   const evidenceManifest = gateResult.evidence || (options.evidence ? options.evidence : null);
   const evidenceSection = evidenceManifest
-    ? `\n### 🛡️ Cryptographic Evidence Manifest\n- **Manifest ID:** \`${evidenceManifest.manifestId}\`\n- **Signature:** \`${evidenceManifest.evidenceHash?.slice(0, 16)}...\`\n- **Test Integrity:** ${evidenceManifest.testIntegrity?.tamperDetected ? "❌ Tampered" : "✅ Verified (0 test weakening)"}\n`
+    ? `\n### Evidence Manifest\n- **Manifest ID:** \`${evidenceManifest.manifestId}\`\n- **Digest:** \`${evidenceManifest.evidenceHash?.slice(0, 16)}...\`\n- **Test Integrity:** ${evidenceManifest.testIntegrity?.tamperDetected ? "❌ Tampered" : "✅ Verified (0 test weakening)"}\n`
     : "";
 
   const modifiedFiles = options.modifiedFiles || [];
   const affectedTests = resolveAffectedTests(modifiedFiles, options);
 
-  const prBody = `## 🚀 Autonomous Jules Agent Execution Evidence
+  const prBody = `## Autonomous Agent Execution Summary
 
-### ⏱️ OODA Verification Trace
+### Verification Trace
 - **Session ID:** \`${sessionId}\`
 - **OODA Turns:** \`${attemptsCount}/${maxAttempts}\`
 - **Warm Resumption:** ${isWarm ? "✅ Active Context Stream" : "Cold Start"}
 - **Execution Latency:** \`${durationSec}s\`
 ${evidenceSection}
-### 🛡️ Zero-Trust Security Audit Matrix
+### Security & Scope Audit
 - **Scope Guard:** ${scopePhase.ok ? "✅ PASS (0 protected path violations)" : "❌ FAIL"}
-- **Diff Payload Governor:** ${payloadPhase.ok ? `✅ PASS (${kbDiff} KB / ${kbLimit} KB limit)` : "❌ EXCEEDED"}
-- **Secret Scanner:** ${secretPhase.ok ? "✅ PASS (0 high-entropy leaks detected)" : "❌ LEAKS FOUND"}
+- **Diff Payload Budget:** ${payloadPhase.ok ? `✅ PASS (${kbDiff} KB / ${kbLimit} KB limit)` : "❌ EXCEEDED"}
+- **Secret Scanner:** ${secretPhase.ok ? "✅ PASS (0 credentials detected)" : "❌ LEAKS FOUND"}
 
-### 🧪 Terminal Verification Evidence
+### Terminal Verification Output
 \`\`\`text
 ${options.testOutput || "All verification tests passed with Exit Code 0."}
 \`\`\`
 
-### 📂 AST Impact & Dependency Graph
+### Affected Tests & Impact Analysis
 ${
   affectedTests === null
     ? "- **Impact Scope:** ⚠️ Global contract change detected (`package.json`/`tsconfig`/`schema`). Full test suite executed."

package/src/execution-envelope.mjs

@@ -0,0 +1,111 @@
+import { createHash } from "node:crypto";
+import { resolveRoot } from "./config.mjs";
+import { resolveBase } from "./git.mjs";
+import { classifyRiskTier } from "./risk.mjs";
+import { queryRemediations } from "./remediation.mjs";
+
+/**
+ * Generates a SHA-256 hash of the execution envelope payload.
+ */
+export function hashExecutionEnvelope(envelope) {
+  if (!envelope || typeof envelope !== "object") return "";
+  const rawPayload = {
+    id: envelope.id,
+    taskId: envelope.taskId,
+    baseRef: envelope.baseRef,
+    baseSha: envelope.baseSha,
+    configSha: envelope.configSha,
+    scope: envelope.scope,
+    verify: envelope.verify,
+    riskTier: envelope.riskTier,
+    budgetReservationId: envelope.budgetReservationId,
+    capabilities: envelope.capabilities,
+    remediations: envelope.remediations || [],
+    createdAt: envelope.createdAt,
+  };
+  const sortedKeys = Object.keys(rawPayload).sort();
+  const canonicalPayload = {};
+  for (const k of sortedKeys) {
+    if (rawPayload[k] !== undefined) {
+      canonicalPayload[k] = rawPayload[k];
+    }
+  }
+  return createHash("sha256").update(JSON.stringify(canonicalPayload)).digest("hex");
+}
+
+/**
+ * Deep freezes an execution envelope to prevent modifications during OODA repair loops.
+ */
+export function freezeExecutionEnvelope(envelope) {
+  if (!envelope || typeof envelope !== "object") return envelope;
+  return Object.freeze({
+    ...envelope,
+    scope: Object.freeze({
+      deny: Object.freeze([...(envelope.scope?.deny || [])]),
+      allow: Object.freeze([...(envelope.scope?.allow || [])]),
+      protect: Object.freeze([...(envelope.scope?.protect || [])]),
+    }),
+    verify: Object.freeze({ ...(envelope.verify || {}) }),
+    capabilities: Object.freeze([...(envelope.capabilities || [])]),
+    remediations: Object.freeze([...(envelope.remediations || [])]),
+  });
+}
+
+/**
+ * Creates an immutable Capability-Bounded Execution Envelope (CBEE) with pre-flight remediation hydration.
+ */
+export function createExecutionEnvelope(task = {}, opts = {}) {
+  const root = opts.root || resolveRoot();
+  const baseRef = opts.base || task.base || "main";
+  const baseSha = resolveBase(root, baseRef);
+
+  const taskId = task.id || opts.taskId || `task-${Date.now()}`;
+  const envelopeId = `env-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
+
+  const denyPaths = opts.forbiddenPaths || task.forbiddenPaths || [".github/**", "package-lock.json", "pnpm-lock.yaml"];
+  const allowPaths = opts.allowPaths || task.allowPaths || [];
+  const protectPaths = opts.protectPaths || task.protectPaths || ["package.json", "tsconfig.json", "AGENTS.md"];
+
+  const files = task.files || opts.files || [];
+  const riskMeta = classifyRiskTier(files, { diffLines: opts.diffLines || 0 });
+
+  const taskFingerprint = task.fingerprint || opts.fingerprint || null;
+  const remediations = queryRemediations(root, { targetFiles: files, fingerprint: taskFingerprint, limit: 3 });
+
+  const rawEnvelope = {
+    id: envelopeId,
+    taskId,
+    baseRef,
+    baseSha,
+    configSha: createHash("sha256").update(JSON.stringify({ denyPaths, allowPaths, protectPaths })).digest("hex"),
+    scope: {
+      deny: denyPaths,
+      allow: allowPaths,
+      protect: protectPaths,
+    },
+    verify: {
+      testCmd: opts.testCmd || task.testCmd || "npm test",
+      buildCmd: opts.buildCmd || task.buildCmd || "npm run build",
+    },
+    riskTier: riskMeta.tier,
+    budgetReservationId: opts.reservationId || null,
+    capabilities: opts.capabilities || ["git:read", "git:diff", "test:run"],
+    remediations,
+    createdAt: new Date().toISOString(),
+  };
+
+  const envelopeHash = hashExecutionEnvelope(rawEnvelope);
+  const fullEnvelope = { ...rawEnvelope, hash: envelopeHash };
+
+  return freezeExecutionEnvelope(fullEnvelope);
+}
+
+/**
+ * Validates that an envelope has not been tampered with.
+ */
+export function verifyExecutionEnvelope(envelope) {
+  if (!envelope || !envelope.hash) return false;
+  const expectedHash = hashExecutionEnvelope(envelope);
+  return envelope.hash === expectedHash;
+}
+

package/src/execution_envelope.mjs

@@ -1,111 +1 @@
-import { createHash } from "node:crypto";
-import { resolveRoot } from "./config.mjs";
-import { resolveBase } from "./git.mjs";
-import { classifyRiskTier } from "./risk.mjs";
-import { queryRemediations } from "./remediation.mjs";
-
-/**
- * Generates a SHA-256 hash of the execution envelope payload.
- */
-export function hashExecutionEnvelope(envelope) {
-  if (!envelope || typeof envelope !== "object") return "";
-  const rawPayload = {
-    id: envelope.id,
-    taskId: envelope.taskId,
-    baseRef: envelope.baseRef,
-    baseSha: envelope.baseSha,
-    configSha: envelope.configSha,
-    scope: envelope.scope,
-    verify: envelope.verify,
-    riskTier: envelope.riskTier,
-    budgetReservationId: envelope.budgetReservationId,
-    capabilities: envelope.capabilities,
-    remediations: envelope.remediations || [],
-    createdAt: envelope.createdAt,
-  };
-  const sortedKeys = Object.keys(rawPayload).sort();
-  const canonicalPayload = {};
-  for (const k of sortedKeys) {
-    if (rawPayload[k] !== undefined) {
-      canonicalPayload[k] = rawPayload[k];
-    }
-  }
-  return createHash("sha256").update(JSON.stringify(canonicalPayload)).digest("hex");
-}
-
-/**
- * Deep freezes an execution envelope to prevent modifications during OODA repair loops.
- */
-export function freezeExecutionEnvelope(envelope) {
-  if (!envelope || typeof envelope !== "object") return envelope;
-  return Object.freeze({
-    ...envelope,
-    scope: Object.freeze({
-      deny: Object.freeze([...(envelope.scope?.deny || [])]),
-      allow: Object.freeze([...(envelope.scope?.allow || [])]),
-      protect: Object.freeze([...(envelope.scope?.protect || [])]),
-    }),
-    verify: Object.freeze({ ...(envelope.verify || {}) }),
-    capabilities: Object.freeze([...(envelope.capabilities || [])]),
-    remediations: Object.freeze([...(envelope.remediations || [])]),
-  });
-}
-
-/**
- * Creates an immutable Capability-Bounded Execution Envelope (CBEE) with pre-flight remediation hydration.
- */
-export function createExecutionEnvelope(task = {}, opts = {}) {
-  const root = opts.root || resolveRoot();
-  const baseRef = opts.base || task.base || "main";
-  const baseSha = resolveBase(root, baseRef);
-
-  const taskId = task.id || opts.taskId || `task-${Date.now()}`;
-  const envelopeId = `env-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`;
-
-  const denyPaths = opts.forbiddenPaths || task.forbiddenPaths || [".github/**", "package-lock.json", "pnpm-lock.yaml"];
-  const allowPaths = opts.allowPaths || task.allowPaths || [];
-  const protectPaths = opts.protectPaths || task.protectPaths || ["package.json", "tsconfig.json", "AGENTS.md"];
-
-  const files = task.files || opts.files || [];
-  const riskMeta = classifyRiskTier(files, { diffLines: opts.diffLines || 0 });
-
-  const taskFingerprint = task.fingerprint || opts.fingerprint || null;
-  const remediations = queryRemediations(root, { targetFiles: files, fingerprint: taskFingerprint, limit: 3 });
-
-  const rawEnvelope = {
-    id: envelopeId,
-    taskId,
-    baseRef,
-    baseSha,
-    configSha: createHash("sha256").update(JSON.stringify({ denyPaths, allowPaths, protectPaths })).digest("hex"),
-    scope: {
-      deny: denyPaths,
-      allow: allowPaths,
-      protect: protectPaths,
-    },
-    verify: {
-      testCmd: opts.testCmd || task.testCmd || "npm test",
-      buildCmd: opts.buildCmd || task.buildCmd || "npm run build",
-    },
-    riskTier: riskMeta.tier,
-    budgetReservationId: opts.reservationId || null,
-    capabilities: opts.capabilities || ["git:read", "git:diff", "test:run"],
-    remediations,
-    createdAt: new Date().toISOString(),
-  };
-
-  const envelopeHash = hashExecutionEnvelope(rawEnvelope);
-  const fullEnvelope = { ...rawEnvelope, hash: envelopeHash };
-
-  return freezeExecutionEnvelope(fullEnvelope);
-}
-
-/**
- * Validates that an envelope has not been tampered with.
- */
-export function verifyExecutionEnvelope(envelope) {
-  if (!envelope || !envelope.hash) return false;
-  const expectedHash = hashExecutionEnvelope(envelope);
-  return envelope.hash === expectedHash;
-}
-
+export * from "./execution-envelope.mjs";

package/src/git.mjs

@@ -138,8 +138,11 @@ export function git(args = [], opts = {}) {
 }
 
 export function ensureBaseFetched(root = process.cwd(), baseRef = "main") {
+  if (!baseRef || typeof baseRef !== "string" || baseRef.startsWith("-") || !/^[A-Za-z0-9._/-]+$/.test(baseRef)) {
+    return false;
+  }
   try {
-    execFileSync("git", ["fetch", "origin", baseRef, "--depth=100"], {
+    execFileSync("git", ["fetch", "origin", "--", baseRef, "--depth=100"], {
       cwd: root,
       encoding: "utf-8",
       shell: false,
@@ -148,7 +151,7 @@ export function ensureBaseFetched(root = process.cwd(), baseRef = "main") {
     return true;
   } catch (_) {
     try {
-      execFileSync("git", ["fetch", "origin", baseRef, "--unshallow"], {
+      execFileSync("git", ["fetch", "origin", "--", baseRef, "--unshallow"], {
         cwd: root,
         encoding: "utf-8",
         shell: false,
@@ -236,7 +239,7 @@ export function diffText(root = process.cwd(), base = "main", mode = "committed"
         if (existsSync(fullPath)) {
           const content = readFileSync(fullPath, "utf-8");
           untrackedDiff += `\ndiff --git a/${file} b/${file}\nnew file mode 100644\n--- /dev/null\n+++ b/${file}\n`;
-          untrackedDiff += content.split("\n").map((line) => `+${line}`).join("\n") + "\n";
+          untrackedDiff += content.split(/\r?\n/).map((line) => `+${line}`).join("\n") + "\n";
         }
       } catch (_) {}
     }