jules-orchestrator-kit 0.66.0 → 0.67.0

package/README.md

@@ -207,7 +207,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, with a `node --check` syntax-verification gate that transparently escalates a FAST-tier result to the primary provider if it left broken JS on disk.
 * **Terminal UI & Diagnostic Matrix (`agentctl doctor`):** Interactive terminal dashboard, task sidecar manager, and automated transactional self-repair.
-* **Verified Test Suite:** Tested with **1133 unit tests across 163 suites passing in < 15.0s**.
+* **Verified Test Suite:** Tested with **1154 unit tests across 166 suites passing in < 15.0s**.
 
 <br/>
 

package/bin/agentctl.mjs

@@ -425,7 +425,17 @@ async function main() {
         console.log(`-----------------------------------------------------`);
         for (const p of res.phases) {
           const status = p.ok ? "✅ PASS" : "❌ FAIL";
-          console.log(`  Phase [${p.phase.toUpperCase()}] : ${status}`);
+          // Test tampering shares this phase, and its exit code, with the
+          // secret scanner. The codes are frozen, but reporting an assertion
+          // deletion under a bare "SECRETS" heading sent operators looking for
+          // a credential to rotate. Name what actually failed.
+          const tamperOnly =
+            p.phase === "secrets" &&
+            !p.ok &&
+            (p.findings || []).length > 0 &&
+            (p.findings || []).every((f) => f.type !== "SECRET_DETECTED" && !/SECRET/i.test(f.type || ""));
+          const label = tamperOnly ? "SECRETS (test integrity — no secret found)" : p.phase.toUpperCase();
+          console.log(`  Phase [${label}] : ${status}`);
           if (p.violations) {
             p.violations.forEach((v) => console.log(`     - Violation: ${v.file} (Rule: ${v.rule})`));
           }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jules-orchestrator-kit",
-  "version": "0.66.0",
+  "version": "0.67.0",
   "description": "Zero-dependency safety gatekeeper, test oracle generator, and multi-agent coordination protocol for autonomous coding agents — Google Jules, Claude Code, Codex and Gemini CLI.",
   "repository": {
     "type": "git",

package/scripts/guard-reach-check.mjs

@@ -56,6 +56,7 @@ import {
   SCOPE_CANARIES,
   INNOCENT_EDITS,
   UNREADABLE_DIALECTS,
+  CROSS_FILE_CASES,
 } from "../src/guard-policy.mjs";
 
 /**
@@ -185,6 +186,29 @@ const canaryResults = new Map();
   );
 }
 
+{
+  const wrong = [];
+  for (const c of CROSS_FILE_CASES) {
+    const lines = [];
+    for (const f of c.files) {
+      lines.push(`--- a/${f.file}`, `+++ b/${f.file}`, "@@ -1,20 +1,20 @@", ` ${c.context}`);
+      for (const l of f.removed) lines.push(`-${l}`);
+      for (const l of f.added) lines.push(`+${l}`);
+      lines.push(` ${c.context}`);
+    }
+    const got = (checkTestTampering(lines.join("\n")).violations || []).map((v) => v.type).sort();
+    const want = [...c.expect].sort();
+    if (JSON.stringify(got) !== JSON.stringify(want)) {
+      wrong.push(`${c.id}: got ${JSON.stringify(got)}, policy says ${JSON.stringify(want)} (${c.why})`);
+    }
+  }
+  add(
+    "a move across files is judged as a move",
+    wrong.length === 0,
+    wrong.length ? wrong.join("; ") : `${CROSS_FILE_CASES.length} two-file diffs judged as declared`
+  );
+}
+
 // --- 4. Predicate mutants ---------------------------------------------------
 {
   const survivors = [];

package/scripts/run-tests.mjs

@@ -1,11 +1,28 @@
 #!/usr/bin/env node
-import { readdirSync } from "node:fs";
+import { readdirSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { spawn, spawnSync } from "node:child_process";
 import { cpus } from "node:os";
 
 const root = process.cwd();
 const testDir = join(root, "test");
+
+// The published package ships `scripts/` and not `test/`, so running
+// `npm test` inside an installed copy crashed with a raw
+// `ENOENT: no such file or directory, scandir '.../test'`. The suite is not
+// missing; it was never part of the tarball. Say that, rather than leaving
+// someone to work it out from a stack trace.
+if (!existsSync(testDir)) {
+  console.error("No test/ directory here.");
+  console.error("");
+  console.error("If this is an installed copy of jules-orchestrator-kit, that is expected:");
+  console.error("the test suite is not part of the published package. Clone the repository");
+  console.error("to run it:  git clone https://github.com/FullThrottle83/jules-orchestrator-kit");
+  console.error("");
+  console.error("To check an installed copy instead, run:  npm run guard-reach");
+  process.exit(1);
+}
+
 const testFiles = readdirSync(testDir)
   .filter((f) => f.endsWith(".test.mjs"))
   .sort()

package/src/guard-policy.mjs

@@ -235,6 +235,58 @@ export const TAMPER_CANARIES = [
     added: ["        $this->markTestSkipped(\"later\");"],
     expect: "TEST_SKIP_INJECTION",
   },
+  // Skipping from inside the test body, which is how every one of these
+  // ecosystems actually does it. The decorator and annotation forms were
+  // covered; the standard library's own method was not, so a test could be
+  // silenced with the most ordinary call in the language.
+  {
+    id: "skip-injection/unittest-body",
+    file: "tests/test_app.py",
+    context: "# app",
+    removed: [],
+    added: ['        self.skipTest("disabled")'],
+    expect: "TEST_SKIP_INJECTION",
+  },
+  {
+    id: "skip-injection/pytest-body",
+    file: "tests/test_app.py",
+    context: "# app",
+    removed: [],
+    added: ['    pytest.skip("not now")'],
+    expect: "TEST_SKIP_INJECTION",
+  },
+  {
+    id: "skip-injection/raise-skiptest",
+    file: "tests/test_app.py",
+    context: "# app",
+    removed: [],
+    added: ['    raise unittest.SkipTest("nope")'],
+    expect: "TEST_SKIP_INJECTION",
+  },
+  {
+    id: "skip-injection/mocha-body",
+    file: "test/app.test.js",
+    context: "// app",
+    removed: [],
+    added: ["  this.skip();"],
+    expect: "TEST_SKIP_INJECTION",
+  },
+  {
+    id: "skip-injection/jest-todo",
+    file: "test/app.test.js",
+    context: "// app",
+    removed: [],
+    added: ['  test.todo("adds two numbers");'],
+    expect: "TEST_SKIP_INJECTION",
+  },
+  {
+    id: "skip-injection/go-skipnow",
+    file: "internal/calc/calc_test.go",
+    context: "// calc",
+    removed: [],
+    added: ["\tt.SkipNow()"],
+    expect: "TEST_SKIP_INJECTION",
+  },
   {
     id: "skip-injection/xctest",
     file: "Tests/CalcTests/CalcTests.swift",
@@ -551,3 +603,57 @@ export const MULTILINE_CANARIES = [
     expect: "ASSERTION_EXPECTATION_CHANGED",
   },
 ];
+
+/**
+ * Diffs that touch two files at once, where the verdict depends on both.
+ *
+ * Assertion tracking is per file, so moving a test between files — ordinary
+ * refactoring, done constantly — read as deleting every assertion in it and
+ * was reported as CRITICAL tampering. The assertion still exists and still
+ * runs. What the removal check is for is verification that *disappeared*.
+ *
+ * `expect: []` means the whole diff must produce no finding.
+ */
+export const CROSS_FILE_CASES = [
+  {
+    id: "move-a-test-between-files",
+    context: "# ctx",
+    files: [
+      {
+        file: "test/test_app.py",
+        removed: ["    def test_setattr(self):", "        self.assertEqual(5, app.test)", "        self.assertRaises(AttributeError, setattr, app, 't', 6)"],
+        added: [],
+      },
+      {
+        file: "test/test_html.py",
+        removed: [],
+        added: ["    def test_setattr_moved(self):", "        self.assertEqual(5, app.test)", "        self.assertRaises(AttributeError, setattr, app, 't', 6)"],
+      },
+    ],
+    expect: [],
+    why: "a move is not a removal",
+  },
+  {
+    id: "delete-a-test-outright",
+    context: "# ctx",
+    files: [
+      {
+        file: "test/test_app.py",
+        removed: ["    def test_setattr(self):", "        self.assertEqual(5, app.test)", "        self.assertRaises(AttributeError, setattr, app, 't', 6)"],
+        added: [],
+      },
+    ],
+    expect: ["ASSERTION_REMOVAL", "ASSERTION_REMOVAL"],
+    why: "nothing caught it on the way, so verification really did disappear",
+  },
+  {
+    id: "change-it-on-the-way-across",
+    context: "# ctx",
+    files: [
+      { file: "test/test_app.py", removed: ["        self.assertEqual(5, app.test)"], added: [] },
+      { file: "test/test_html.py", removed: [], added: ["        self.assertEqual(99, app.test)"] },
+    ],
+    expect: ["ASSERTION_REMOVAL"],
+    why: "what arrived is a different claim; only an exact arrival is a move",
+  },
+];

package/src/security.mjs

@@ -2195,6 +2195,17 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     { pattern: /\b(?:xit|xdescribe|xcontext|xspecify)\b\s*["\x27]/i, desc: "Injected RSpec disabled example (xit)" },
     { pattern: /,\s*skip:\s*(?:true|["\x27])/i, desc: "Injected RSpec skip metadata (skip:)" },
     { pattern: /^\s*(?:skip|pending)\s*(?:["\x27(]|$)/i, desc: "Injected Minitest/RSpec skip statement" },
+    // Skipping from inside the body, which is how these ecosystems actually
+    // do it. Only the decorator and annotation forms were covered, so a test
+    // could be silenced with the standard library's own method and the guard
+    // said nothing: measured silent on six of seven in-body forms.
+    { pattern: /\bself\.skipTest\s*\(/i, desc: "Injected unittest skip (self.skipTest())" },
+    { pattern: /\braise\s+(?:unittest\.)?SkipTest\b/i, desc: "Injected unittest skip (raise SkipTest)" },
+    { pattern: /\bpytest\.skip\s*\(/i, desc: "Injected Pytest skip call (pytest.skip())" },
+    { pattern: /\bpytest\.xfail\s*\(/i, desc: "Injected Pytest expected-failure (pytest.xfail())" },
+    { pattern: /\bthis\.skip\s*\(/i, desc: "Injected Mocha skip (this.skip())" },
+    { pattern: /\b(?:it|test|describe|context)\.todo\s*\(/i, desc: "Injected todo placeholder (test.todo())" },
+    { pattern: /\bt\.Skip(?:Now|f)?\s*\(/, desc: "Injected Go test skip (t.Skip/t.Skipf/t.SkipNow)" },
   ];
 
   // `#` and `--` belong here for the same reason the dialects belong in
@@ -2369,6 +2380,26 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     }
   }
 
+  // Assertions added in some *other* file of this same diff.
+  //
+  // Tracking is strictly per file, so moving a test from one file to another
+  // — ordinary refactoring — read as deleting three assertions and was
+  // reported as CRITICAL tampering. The assertion still exists and still
+  // runs; it is in a different file. What the removal check is for is
+  // verification that *disappeared*, and this has not.
+  //
+  // Deliberately exact on the assertion text: something that changed on the
+  // way across is not a move, and is judged normally.
+  const movedIn = new Map();
+  for (const [file, stats] of fileAssertions.entries()) {
+    for (const t of stats.addedTexts || []) {
+      const key = collapseWhitespace(String(t.text ?? t)).trim();
+      if (!key) continue;
+      if (!movedIn.has(key)) movedIn.set(key, []);
+      movedIn.get(key).push(file);
+    }
+  }
+
   for (const [file, stats] of fileAssertions.entries()) {
     // An expectation that was rewritten rather than removed.
     //
@@ -2386,6 +2417,15 @@ export function checkTestTampering(diffOrText = "", options = {}) {
     if (stats.removed.length > stats.added) {
       const unreplaced = stats.removed.slice(stats.added);
       for (const item of unreplaced) {
+        // Did this exact assertion arrive somewhere else in the same diff?
+        const key = collapseWhitespace(item.text).trim();
+        const landing = movedIn.get(key);
+        const elsewhere = landing ? landing.findIndex((f) => f !== file) : -1;
+        if (elsewhere !== -1) {
+          // Consume the landing so two removals cannot both claim one arrival.
+          landing.splice(elsewhere, 1);
+          continue;
+        }
         violations.push({
           file,
           line: item.line,