jules-orchestrator-kit 0.38.1 → 0.38.2

package/README.md

@@ -131,7 +131,7 @@ To maximize PR merge rates, dispatch tasks according to deterministic boundaries
 * **Fail-Closed Security & Secret Redaction:** Evaluates explicit Deny rules before Allow rules against canonicalized, case-folded paths. Redacts high-entropy keys and base64-encoded credentials (such as Kubernetes `Secret` manifests).
 * **Complexity & Cost Router:** Zero-dependency heuristic classifier (`src/router.mjs`) routing mechanical tasks to lightweight models while reserving primary models for complex refactors.
 * **Terminal UI & Diagnostic Matrix (`agentctl doctor`):** Interactive terminal dashboard, task sidecar manager, and automated transactional self-repair.
-* **Verified Test Suite:** Tested with **569 unit tests across 81 suites passing in < 10.0s**.
+* **Verified Test Suite:** Tested with **572 unit tests across 81 suites passing in < 10.0s**.
 
 <br/>
 
@@ -151,7 +151,7 @@ To maximize PR merge rates, dispatch tasks according to deterministic boundaries
 | `task template` | `agentctl task template [<id>] [--list] [--json]` | Lists and synthesizes pre-calibrated web task envelopes (`web-cwv`, `web-wcag`, `web-seo`, `web-playwright`, `web-flaky-heal`, `web-i18n`, `web-ai-access`). | `0` (Listed/Synthesized) |
 | `dispatch` | `agentctl dispatch [-p <prompt>] [-f <file>] [-r <role>] [-t <tier>] [--auto-pr] [--repoless] [--dry-run]` | Dispatches autonomous task to the active provider with payload limits and role prompt resolution. | `0` (Dispatched), `1` (Error) |
 | `doctor` | `agentctl doctor [--json]` | Diagnostic DAG check runner & automated transactional self-repair engine. | `0` (Healthy), `1` (Failures) |
-| `queue` | `agentctl queue [--dag] [--concurrency <n>] [--dry-run] [--json]` | Consumes and executes task envelopes in `.agent/jules-queue/` with Kahn's DAG dependency resolution. | `0` (Complete) |
+| `queue` | `agentctl queue [--dag] [--concurrency <n>] [--dry-run] [--json]` | Consumes and executes task envelopes in `.agent/jules-queue/` with Kahn's DAG dependency resolution. Non-task files (manifests, `README.md`) are skipped, and `--dry-run` previews without moving anything. | `0` (Complete) |
 | `swarm` | `agentctl swarm [--json]` | Runs parallel multi-agent swarm across worker slots with PID liveness detection. | `0` (Complete) |
 | `gate` / `audit`| `agentctl gate --mode working-tree [--json]` | Runs security, secret scanning, and verification gates against working tree or branch. | `0` (Approved), `3` (Scope), `5` (Diff >75K), `6` (Secret) |
 | `rollback` | `agentctl rollback [sessionId \| --latest]` | Restores exact commit, uncommitted files, and cleans orphan task worktrees from pre-flight checkpoints. | `0` (Restored), `1` (Error) |
@@ -319,6 +319,7 @@ console.log(classification.tier); // "fast" | "complex"
 
 | Feature | Module / Command | Architectural Description | Status |
 | :--- | :--- | :--- | :---: |
+| **Queue Runner Fidelity** | `src/dag-engine.mjs`, `src/engine.mjs` | Queue selection is by task shape rather than file extension, so manifests and READMEs are skipped instead of dispatched, and `--dry-run` leaves the queue untouched. | **v0.38.2** *(Shipped)* |
 | **Release Gate Enforcement & Wizard Smoke Test** | `.github/workflows/jules-audit.yml`, `scripts/release.mjs`, `test/wizard-smoke.test.mjs` | Doc-sync gate runs in CI rather than by hand, releases block on a green CI matrix for `HEAD`, per-test deadlines turn a hang into a failure, and the real `init` wizard is driven end to end over a fake TTY. | **v0.38.1** *(Shipped)* |
 | **Multi-OS CI Matrix & TUI Hardening** | `scripts/run-tests.mjs`, `src/state.mjs`, `src/git.mjs` | Automated 9-job CI matrix across Linux, macOS, and Windows on Node 20/22/24 with raw-mode TUI resilience and native Windows command quoting. | **v0.38.0** *(Shipped)* |
 | **Base64 Secret Detection & Budget Fix** | `src/security.mjs`, `src/budget.mjs` | Secret scanner decodes base64 before matching structured patterns (K8s secrets), and `budget reset` preserves confirmed provider sessions. | **v0.37.0** *(Shipped)* |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jules-orchestrator-kit",
-  "version": "0.38.1",
+  "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/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

@@ -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)) {