jules-orchestrator-kit 0.64.0 → 0.66.0

package/README.md

@@ -49,12 +49,15 @@
 <a id="quickstart"></a>
 ## Quickstart
 
-Get running in any repository in 3 commands (zero configuration required):
+Get running in any repository in 3 commands. `init` asks seven questions and
+fills in a sensible answer for each; `--yes` accepts all of them, detects the
+stack, and probes the test command it picked before writing it down.
 
 ```bash
 # 1. Scaffold config, AGENTS.md, role prompts and guardrails
 #    (auto-detects Python, Rust, Go, Node, PHP, etc.)
-npx jules-orchestrator-kit init
+#    Drop --yes to choose provider, plan, profile and workflows yourself.
+npx jules-orchestrator-kit init --yes
 ```
 
 ```bash
@@ -204,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 **1085 unit tests across 150 suites passing in < 15.0s**.
+* **Verified Test Suite:** Tested with **1133 unit tests across 163 suites passing in < 15.0s**.
 
 <br/>
 

package/bin/agentctl.mjs

@@ -429,6 +429,14 @@ async function main() {
           if (p.violations) {
             p.violations.forEach((v) => console.log(`     - Violation: ${v.file} (Rule: ${v.rule})`));
           }
+          if (p.unverified) {
+            console.log(`     - Unverified: ${p.unverified}`);
+          }
+          if (p.setup) {
+            console.log(`     - Setup: accepted ${p.setup.length} gate scaffold file(s) this repository did not have yet`);
+            p.setup.forEach((f) => console.log(`         ${f}`));
+            console.log(`       Commit them to the base branch and the full protect rules apply from then on.`);
+          }
           if (p.findings) {
             p.findings.forEach((f) => console.log(`     - [${f.severity}] ${f.type}: ${f.description}`));
           }
@@ -2662,13 +2670,21 @@ async function main() {
       const taskId = values.task || "unknown";
       const agent = values.agent || "jules";
 
+      const { CONFIRM_AFTER } = await import("../src/memory.mjs");
       const res = harvestFailure(root, { exitCode, logPath, diffText, taskId, agent });
       if (values.json) {
         console.log(JSON.stringify(res, null, 2));
       } else {
         if (res.status === "HARVESTED") {
-          console.log(`🌾 Harvested failure candidate: ${res.candidate.trigger}`);
-          console.log(`   Solution: ${res.candidate.solution}`);
+          // No "Solution:" line any more, because there is no solution: the
+          // repair loop exhausting its budget is the definition of not having
+          // found one. It used to print a fixed sentence here and store it as
+          // if it were a remedy.
+          console.log(`🌾 Recorded failure observation: ${res.candidate.trigger}`);
+          console.log(`   Seen ${res.occurrences}× — ${res.confirmed ? "stated as a rule" : `not injected into prompts until it recurs ${CONFIRM_AFTER}×`}`);
+          if (!res.confirmed) {
+            console.log(`   Record an actual fix for it with: agentctl learning add "<trigger>" "<solution>"`);
+          }
         } else {
           console.log(`⚠️ Harvest rejected: ${res.reason}`);
         }

package/package.json

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

@@ -49,8 +49,10 @@ import { parseCollectedTests } from "../src/ops/test-collection.mjs";
 import {
   TEST_PATH_CASES,
   TAMPER_CANARIES,
+  MULTILINE_CANARIES,
   PREDICATE_MUTANTS,
   EMPTY_RUN_CANARIES,
+  COUNTED_RUN_CANARIES,
   SCOPE_CANARIES,
   INNOCENT_EDITS,
   UNREADABLE_DIALECTS,
@@ -67,6 +69,9 @@ import {
 function canaryDiff(c) {
   const ctx = c.context || "// context";
   const lines = [`--- a/${c.file}`, `+++ b/${c.file}`, "@@ -1,20 +1,20 @@", ` ${ctx}`];
+  // Unchanged lines the change sits inside. An assertion whose keyword is on
+  // one of these is the shape the line-level denominator could not see.
+  for (const l of c.lead || []) lines.push(` ${l}`);
   for (const l of c.removed) lines.push(`-${l}`);
   for (const l of c.added) lines.push(`+${l}`);
   lines.push(` ${ctx}`);
@@ -105,6 +110,17 @@ const add = (name, ok, detail) => {
 
 {
   const missed = EMPTY_RUN_CANARIES.filter((c) => parseCollectedTests(c.output, "").count !== 0);
+  const undercounted = COUNTED_RUN_CANARIES.filter((c) => {
+    const n = parseCollectedTests(c.output, "").count;
+    return n === null || n < c.atLeast;
+  });
+  add(
+    "policy: a stated count is never read as empty",
+    undercounted.length === 0,
+    undercounted.length
+      ? undercounted.map((c) => `${c.id} (${c.why})`).join("; ")
+      : `${COUNTED_RUN_CANARIES.length} healthy runs counted, not rejected`
+  );
   add(
     "policy: empty-run detection",
     missed.length === 0,
@@ -118,7 +134,7 @@ const canaryResults = new Map();
   const silent = [];
   const noDenominator = [];
   const noAssertions = [];
-  for (const c of TAMPER_CANARIES) {
+  for (const c of [...TAMPER_CANARIES, ...MULTILINE_CANARIES]) {
     const res = checkTestTampering(canaryDiff(c));
     const hit = (res.violations || []).some((v) => v.type === c.expect);
     canaryResults.set(c.id, hit);
@@ -132,7 +148,7 @@ const canaryResults = new Map();
       noAssertions.push(`${c.id} (${res.assertionsSeen} assertions parsed)`);
     }
   }
-  add("canaries: every tamper rule still fires", silent.length === 0, silent.length ? silent.join("; ") : `${TAMPER_CANARIES.length} canaries red as required`);
+  add("canaries: every tamper rule still fires", silent.length === 0, silent.length ? silent.join("; ") : `${TAMPER_CANARIES.length + MULTILINE_CANARIES.length} canaries red as required`);
   add("canaries: every finding carries a denominator", noDenominator.length === 0, noDenominator.length ? noDenominator.join(", ") : "inputsSeen > 0 on every hit");
   add("canaries: assertion rules parsed an assertion", noAssertions.length === 0, noAssertions.length ? noAssertions.join(", ") : "assertionsSeen > 0 on every assertion finding");
 }
@@ -174,7 +190,7 @@ const canaryResults = new Map();
   const survivors = [];
   for (const mutant of PREDICATE_MUTANTS) {
     let killed = false;
-    for (const c of TAMPER_CANARIES) {
+    for (const c of [...TAMPER_CANARIES, ...MULTILINE_CANARIES]) {
       // Only canaries the healthy predicate catches can kill a mutant.
       if (!canaryResults.get(c.id)) continue;
       const res = checkTestTampering(canaryDiff(c), { isTestPath: mutant.fn });

package/src/engine.mjs

@@ -204,6 +204,16 @@ export async function gate(opts = {}) {
           // Read from the base commit like every other trusted field: an
           // uncommitted `required: false` must not be able to switch the gate off.
           required: parsed.verify?.required !== undefined ? parsed.verify.required !== false : config.verify.required !== false,
+          // The floor the collection check applies. Omitting it here meant
+          // `verify.minTests` was silently dropped and always defaulted to 1
+          // — while the failure message told the operator to set exactly
+          // that. A remediation hint that does nothing is worse than none.
+          minTests:
+            parsed.verify?.minTests !== undefined
+              ? parsed.verify.minTests
+              : parsed.verify?.min_tests !== undefined
+                ? parsed.verify.min_tests
+                : config.verify.minTests,
           scope: parsed.verify?.scope || config.verify.scope || "global",
           timeoutMs: parsed.verify?.timeoutMs || parsed.verify?.timeout_ms || config.verify.timeoutMs,
         };
@@ -249,7 +259,45 @@ export async function gate(opts = {}) {
     violation.file = link;
   }
 
-  phases.push({ phase: "scope", ok: scopeResult.ok, violations: scopeResult.violations });
+  // Bootstrap: the files that bring a repository under the gate are not agent
+  // edits to the gate.
+  //
+  // `init` writes `.agent/**` and then tells the user to commit it. Doing
+  // exactly that produced Exit 3 on the very first run, because the base
+  // branch does not have the commit yet and every scaffolded path matches
+  // BUILTIN_PROTECT or BUILTIN_DENY. The advice printed alongside it was
+  // `--allow-protected` — so a newcomer's first lesson was how to switch the
+  // scope guard off. A gate that refuses its own installation is not strict,
+  // it is broken.
+  //
+  // Narrow on purpose, and only where it cannot weaken anything: the base
+  // commit must have no gate config at all — in which case `trustedScope` is
+  // already built-ins only and nothing in the added files is trusted — and
+  // every violating path must be scaffold that the base does not have. A
+  // repository already under the gate keeps the full rule, so an agent still
+  // cannot touch the policy it is governed by.
+  let acceptedScaffold = [];
+  if (!scopeResult.ok && !trustedConfigRaw) {
+    const violations = scopeResult.violations || [];
+    const isScaffold = (f) => typeof f === "string" && f.replace(/\\/g, "/").startsWith(".agent/");
+    if (
+      violations.length > 0 &&
+      violations.every((v) => isScaffold(v.file) && showFromOrigin(root, base, v.file) === null)
+    ) {
+      acceptedScaffold = violations.map((v) => v.file);
+      scopeResult.violations = [];
+      scopeResult.ok = true;
+    }
+  }
+
+  phases.push({
+    phase: "scope",
+    ok: scopeResult.ok,
+    violations: scopeResult.violations,
+    // Reported, never silent: the operator has to see that the gate accepted
+    // files it would otherwise have blocked, and why.
+    ...(acceptedScaffold.length > 0 ? { setup: acceptedScaffold } : {}),
+  });
   appendTelemetry(root, "gate_phase", { phase: "scope", ok: scopeResult.ok });
   if (progressBus && progressToken) {
     progressBus.reportProgress(progressToken, 25, 100, "Phase 1/4: Scope Guard verification complete");
@@ -644,6 +692,13 @@ export async function gate(opts = {}) {
       postTestHash,
       tamperDetected: testTampered,
     },
+    // Verified by exit code alone. Not a failure, and not an approval either:
+    // an unrecognised runner passes on purpose, but the operator has to be
+    // able to tell that apart from a suite the gate actually counted.
+    ...(collectionFloor.unverified ? { unverified: collectionFloor.note } : {}),
+    ...(collectionFloor.count !== null && collectionFloor.count !== undefined
+      ? { testsCollected: collectionFloor.count, runner: collectionFloor.runner }
+      : {}),
   });
   phases.push({
     phase: "evidence",

package/src/guard-policy.mjs

@@ -382,6 +382,15 @@ export const INNOCENT_EDITS = [
     added: ['const calc = require("../src/calc");'],
     why: "`require(` is an import, not a claim — the loose net must not read it as one",
   },
+  {
+    id: "reword-comment-inside-assertion/node",
+    file: "test/calc.test.js",
+    context: "// arithmetic",
+    lead: ["  assert.equal(", "    add(1, 2),"],
+    removed: ["    3, // the answer", "  );"],
+    added: ["    3, // the correct answer", "  );"],
+    why: "line comments were never stripped — `copyCode(i)` left `pending` at the comment and the copy after the loop put it back",
+  },
   {
     id: "rename-helper/node",
     file: "test/calc.test.js",
@@ -479,3 +488,66 @@ IMPORT_EXTRACTION_CASES.push(
     why: "same, in the other place examples live",
   }
 );
+
+/**
+ * Runs that stated a count, which must never be read as empty.
+ *
+ * The floor was written to be one-sided — only a *stated* zero fails — and
+ * then a phrase was allowed to outrank a statement. A healthy 190-test TAP
+ * suite whose one skipped fixture printed `# SKIP no tests found` was
+ * rejected as empty and attributed to Jest, in a repository that does not
+ * use Jest. A false red on a correct repository is how a user learns the
+ * gate is broken and turns it off.
+ */
+export const COUNTED_RUN_CANARIES = [
+  {
+    id: "tap with a skip message",
+    output: "TAP version 13\n# Subtest: performance\n    # SKIP no tests found\nok 1 - performance # SKIP\n1..191\n# tests 191\n# pass 190\n# skip 1",
+    atLeast: 1,
+    why: "`no tests found` inside a skip comment is not a statement about the run",
+  },
+  {
+    id: "pytest mentioning an empty module",
+    output: "collected 12 items\n\ntests/test_a.py ............\n\n12 passed in 0.3s",
+    atLeast: 1,
+    why: "a stated count is present and must win",
+  },
+  {
+    id: "go, verbose, two tests",
+    output: "--- PASS: TestAdd (0.00s)\n--- PASS: TestSub (0.00s)\nok  \texample.com/lib\t0.004s",
+    atLeast: 1,
+    why: "Go's own `ok  <package>` line, which a bare `^ok\\s` confused with TAP's `ok 1 - name`",
+  },
+];
+
+/**
+ * Changes that sit inside an assertion whose keyword never appears in the diff.
+ *
+ * Counting `+`/`-` lines answered zero here, and nothing among the changed
+ * lines looked assertion-shaped either, so the guard reported a clean PASS on
+ * a five-element expected list rewritten to one element to match broken
+ * output. Measured on a real repository: five green phases, `APPROVED`.
+ *
+ * The statement machinery that pairs rewrites already assembles context lines
+ * together with changed ones. The denominator has to use it.
+ */
+export const MULTILINE_CANARIES = [
+  {
+    id: "expectation/python-multiline",
+    file: "tests/test_headers.py",
+    context: "# headers",
+    lead: ["    def test_parse(self):", "        self.assertEqual(", "            _parse_http_header(x),"],
+    removed: ['            [("text/xml", {}),', '             ("text/plain", {}),', '             ("more", {})])'],
+    added: ['            [("text/xml", {"tampered": True})])'],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+  {
+    id: "expectation/js-multiline",
+    file: "test/headers.test.js",
+    context: "// headers",
+    lead: ["  assert.deepStrictEqual(", "    parse(input),"],
+    removed: ["    [{ type: \"a\" }, { type: \"b\" }, { type: \"c\" }]", "  );"],
+    added: ["    [{ type: \"a\" }]", "  );"],
+    expect: "ASSERTION_EXPECTATION_CHANGED",
+  },
+];

package/src/ops/test-collection.mjs

@@ -71,8 +71,15 @@ const EXPLICIT_ZERO = [
 
 /** Go prints this per package that has no test files at all. */
 const GO_NO_TEST_FILES = /\[no test files\]/;
-/** Any sign that a Go package did run tests. */
-const GO_RAN_SOMETHING = /^(?:ok|FAIL|---\s+(?:PASS|FAIL|SKIP)):?\s/m;
+/**
+ * Any sign that a Go package did run tests.
+ *
+ * The negative lookahead is what separates Go from TAP. `ok 1 - performance`
+ * is a TAP result line and `ok  example.com/lib 0.004s` is a Go package
+ * summary, and a bare `^ok\s` matched both — so a 190-test TAP suite was
+ * classified as Go and reported as having stated no count at all.
+ */
+const GO_RAN_SOMETHING = /^(?:(?:ok|FAIL)\s+(?!\d+\s)\S+|---\s+(?:PASS|FAIL|SKIP):?\s)/m;
 
 /**
  * Read a collected-test count out of a runner's output.
@@ -87,8 +94,20 @@ export function parseCollectedTests(stdout = "", stderr = "") {
   const text = `${stdout || ""}\n${stderr || ""}`;
   if (!text.trim()) return { count: null, runner: null };
 
-  for (const rule of EXPLICIT_ZERO) {
-    if (rule.re.test(text)) return { count: 0, runner: rule.name };
+  // A stated count wins over a phrase that merely resembles one.
+  //
+  // `EXPLICIT_ZERO` used to be consulted first, so any output containing the
+  // words "no tests found" was read as a zero — including a healthy TAP run
+  // of 190 passing tests whose one skipped fixture printed
+  // `# SKIP no tests found`. The gate rejected the suite as empty and named
+  // Jest as the runner, in a repository that does not use Jest. A phrase
+  // appears anywhere in a stream; a count is stated deliberately, so the
+  // count is the better witness and has to be asked first.
+  for (const rule of COUNT_PATTERNS) {
+    const m = rule.re.exec(text);
+    if (!m) continue;
+    const n = Number(m[1]);
+    if (Number.isFinite(n)) return { count: n, runner: rule.name };
   }
 
   // Go states absence per package rather than as a count, so it needs its own
@@ -104,11 +123,9 @@ export function parseCollectedTests(stdout = "", stderr = "") {
     return { count: perTest && perTest.length > 0 ? perTest.length : null, runner: "go" };
   }
 
-  for (const rule of COUNT_PATTERNS) {
-    const m = rule.re.exec(text);
-    if (!m) continue;
-    const n = Number(m[1]);
-    if (Number.isFinite(n)) return { count: n, runner: rule.name };
+  // Only now: no runner stated a number, so a declared absence is all there is.
+  for (const rule of EXPLICIT_ZERO) {
+    if (rule.re.test(text)) return { count: 0, runner: rule.name };
   }
 
   return { count: null, runner: null };
@@ -131,7 +148,24 @@ export function checkCollectionFloor(testResult, opts = {}) {
   }
 
   const { count, runner } = parseCollectedTests(testResult.stdout, testResult.stderr);
-  if (count === null || count >= minTests) {
+
+  // Deliberately one-sided: only a *stated* zero fails, because failing on
+  // "I could not tell" would break every runner not on the list. But passing
+  // and saying nothing makes `echo "all tests passed"` indistinguishable from
+  // a real suite, so the absence of evidence is reported as an absence.
+  if (count === null) {
+    return {
+      ok: true,
+      count: null,
+      runner: null,
+      reason: null,
+      unverified: true,
+      note:
+        `The verification command exited 0, but no recognised test runner stated how many tests it ran, ` +
+        `so the gate cannot tell a full suite from a command that ran nothing. Verified by exit code alone.`,
+    };
+  }
+  if (count >= minTests) {
     return { ok: true, count, runner, reason: null };
   }
 

package/src/security.mjs

@@ -1523,8 +1523,13 @@ function stripComments(text, lang) {
         continue;
       }
 
-      if (c === "/" && c2 === "/") { copyCode(i); break; }
-      if (lang === "python" && c === "#") { copyCode(i); break; }
+      // `pending = n` is the whole fix. `copyCode(i)` copies the code up to
+      // the comment and leaves `pending` sitting at its start; the
+      // `copyCode(n)` after this loop then copied the comment straight back
+      // in, so no line comment has ever been stripped. Block comments were,
+      // which is why `/* … */` behaved and `// …` did not.
+      if (c === "/" && c2 === "/") { copyCode(i); pending = n; break; }
+      if (lang === "python" && c === "#") { copyCode(i); pending = n; break; }
       if (c === "/" && c2 === "*") {
         copyCode(i);
         state.block = 1;
@@ -1929,6 +1934,9 @@ function detectExpectationRewrites(file, hunks, stats, violations) {
     }
 
     const pairs = [];
+    const pairedOld = new Set();
+    const pairedNew = new Set();
+    const cancelled = new Set();
     for (const [shape, olds] of oldByShape) {
       const news = newByShape.get(shape) || [];
 
@@ -1946,20 +1954,69 @@ function detectExpectationRewrites(file, hunks, stats, violations) {
       const survivingOld = [];
       for (const o of olds) {
         const twin = survivingNew.findIndex((n) => n.canon === o.canon);
-        if (twin === -1) survivingOld.push(o);
-        else survivingNew.splice(twin, 1);
+        if (twin === -1) {
+          survivingOld.push(o);
+        } else {
+          // Present unchanged on both sides: this assertion did not change,
+          // and the argument-level pass below must not be allowed to pair it
+          // with something else and call that a rewrite.
+          cancelled.add(o);
+          cancelled.add(survivingNew[twin]);
+          survivingNew.splice(twin, 1);
+        }
       }
 
       const k = Math.min(survivingOld.length, survivingNew.length);
       for (let t = 0; t < k; t++) {
         const r = survivingOld[t];
         const a = survivingNew[t];
+        // Whatever this pass decides about a pair — reported, or deliberately
+        // let go as a reorder or a reworded message — is the decision. The
+        // argument-level pass below exists only for statements whose shapes
+        // differ so much that they never met in a bucket here; letting it
+        // re-open a case that was already judged turned a comment edit into a
+        // rewritten expectation.
+        pairedOld.add(r);
+        pairedNew.add(a);
         if (r.canon === a.canon) continue;
         if (differsOnlyInMessage(r.clean, a.clean, lang)) continue;
         pairs.push({ r: r.s, a: a.s });
       }
     }
 
+    // Same assertion, same subject, different expected value.
+    //
+    // Shape pairing compares the statement with its literals blanked, so it
+    // only ever matched assertions whose structure survived the edit. Shrink
+    // a five-element expected list to one element to match broken output and
+    // the two images land in different shape buckets, never pair, and the
+    // rewrite is not reported at all — measured on a real repository, where
+    // it collected five green phases.
+    //
+    // The arguments are the better witness here: when both sides call the
+    // same assertion with the same number of arguments and the *subject*
+    // argument is untouched, what changed is what the test expects of it.
+    for (const r of oldCands) {
+      if (pairedOld.has(r) || cancelled.has(r)) continue;
+      const ra = splitAssertionArgs(r.clean, lang);
+      if (!ra || ra.length < 2) continue;
+      for (const a of newCands) {
+        if (pairedNew.has(a) || cancelled.has(a)) continue;
+        const aa = splitAssertionArgs(a.clean, lang);
+        if (!aa || aa.length !== ra.length) continue;
+        const same = (i) => ra[i].replace(/\s+/g, "") === aa[i].replace(/\s+/g, "");
+        // The subject has to be the same expression, or these are two
+        // different assertions that merely resemble each other.
+        if (!same(0)) continue;
+        if (ra.every((_, i) => same(i))) continue;
+        if (differsOnlyInMessage(r.clean, a.clean, lang)) continue;
+        pairs.push({ r: r.s, a: a.s });
+        pairedOld.add(r);
+        pairedNew.add(a);
+        break;
+      }
+    }
+
     // Zero-context hunk: each image is a single fragment and the assertion
     // keyword may sit outside the hunk entirely. The fragment pair is taken
     // only when both sides normalize to the same shape *and* that shape
@@ -2388,21 +2445,57 @@ export function checkTestTampering(diffOrText = "", options = {}) {
   // understood. `UNREADABLE` is the state that has no business being silent
   // — assertion-shaped lines were present and none of them parsed, which
   // means this repository speaks a dialect the guard does not.
+  // An assertion is a statement, not a line.
+  //
+  // Counting `+`/`-` lines missed the commonest shape in every language with
+  // multi-line calls: `self.assertEqual(` sits on an unchanged context line
+  // and only its argument lines are edited. Nothing among the changed lines
+  // matched an assertion pattern, nothing looked assertion-shaped either, so
+  // the guard reported `assertionsSeen: 0` and — because no line looked
+  // suspicious — a clean PASS. A five-element expected list rewritten to one
+  // element to match broken output sailed through five green phases.
+  //
+  // The statement machinery that already exists for pairing knows better:
+  // it assembles context lines together with changed ones. Ask it.
+  for (const [file, stats] of fileAssertions.entries()) {
+    const lang = langForTestFile(file);
+    let touched = 0;
+    for (const hunk of stats.hunks) {
+      const oldSlice = [];
+      const newSlice = [];
+      for (const L of hunk.lines) {
+        if (L.kind !== "+") oldSlice.push(L);
+        if (L.kind !== "-") newSlice.push(L);
+      }
+      for (const stmts of [assembleStatements(oldSlice, lang), assembleStatements(newSlice, lang)]) {
+        for (const st of stmts) {
+          const changed = (st.removedLines?.length || 0) + (st.addedLines?.length || 0) > 0;
+          if (changed && ASSERTION_PATTERN.test(stripComments(st.text, lang))) touched++;
+        }
+      }
+    }
+    stats.statementAssertions = touched;
+  }
+
   let examined = 0;
   let assertionsSeen = 0;
   const unreadable = [];
   for (const [file, stats] of fileAssertions.entries()) {
     examined += stats.examined;
-    assertionsSeen += stats.recognised;
+    assertionsSeen += Math.max(stats.recognised, stats.statementAssertions || 0);
     if (stats.unreadable.length > 0) {
       unreadable.push({ file, count: stats.unreadable.length, samples: stats.unreadable.slice(0, 3) });
     }
   }
 
+  // Changed lines inside a test file, none of them recognisable as part of an
+  // assertion, is not the same as "checked and clean" — it is the state where
+  // this guard has nothing to say. Saying nothing and saying "approved" have
+  // to look different, which is the whole reason `status` exists.
   const status =
     reported.length > 0
       ? "FAIL"
-      : assertionsSeen === 0 && unreadable.length > 0
+      : assertionsSeen === 0 && (unreadable.length > 0 || examined > 0)
         ? "UNREADABLE"
         : examined > 0
           ? "PASS"
@@ -2480,6 +2573,26 @@ export function scanDiff(diffTextStr = "", options = {}) {
     }
   }
 
+  // The gate calls `scanDiff`, not `assertTestIntegrity` — so wiring the
+  // dialect warning into the latter meant it reached nobody. The guard
+  // computed `UNREADABLE`, and the operator was shown an unblemished pass.
+  // A boundary that is not reported is not a boundary.
+  if (tamperingRes.status === "UNREADABLE") {
+    const where = (tamperingRes.unreadable || []).map((u) => u.file);
+    const sample = tamperingRes.unreadable?.[0]?.samples?.[0];
+    findings.push({
+      severity: "MEDIUM",
+      type: "TEST_DIALECT_UNREADABLE",
+      file: where[0] ?? null,
+      line: null,
+      description:
+        `Test Tamper Guard: changed ${tamperingRes.inputsSeen} line(s) in ${tamperingRes.filesSeen} test file(s) ` +
+        `and recognised no assertion among them${sample ? ` (e.g. ${JSON.stringify(sample)})` : ""}. ` +
+        `This change was NOT checked for tampering. That is not a failure — an unlisted assertion library is ` +
+        `normal — but it is not an approval either, so it is reported rather than passed silently.`,
+    });
+  }
+
   return {
     ok: secretsOk && edgeRes.ok && crossPkgRes.ok && tamperingRes.ok,
     findings,

package/src/stack-detector.mjs

@@ -188,6 +188,56 @@ export function detectEdgeRuntime(projectRoot = process.cwd()) {
 /**
  * Detects 24+ polyglot stacks and container environments.
  */
+/**
+ * Test commands worth trying, best first, when the detected one does not run.
+ *
+ * `init` probes the command it picked. On a repository whose Makefile
+ * declares a `test` target that needs a build environment the machine does
+ * not have, that probe failed, printed `Oracle verification probe failed`,
+ * and the wizard wrote the broken command into the config anyway — in a
+ * repository where `pytest` was on PATH and all 360 tests passed in 1.3s.
+ * Measuring something and then ignoring the measurement is worse than not
+ * measuring: it produces a hard red on day one, which is how a user learns
+ * the gate is broken and turns it off.
+ *
+ * Kept deliberately generic — a per-ecosystem convention, never a per-project
+ * or per-provider guess.
+ *
+ * @param {string} root
+ * @param {string} [detected] - the command detection chose; always first.
+ * @returns {string[]} ordered, de-duplicated candidates
+ */
+export function oracleCandidates(root = process.cwd(), detected = "") {
+  const out = [];
+  const push = (c) => {
+    const v = (c || "").trim();
+    if (v && !out.includes(v) && !isPlaceholderTestScript(v)) out.push(v);
+  };
+  const has = (f) => existsSync(join(root, f));
+
+  push(detected);
+
+  if (has("package.json")) {
+    try {
+      const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf-8"));
+      if (pkg.scripts?.test && !isPlaceholderTestScript(pkg.scripts.test)) push("npm test");
+    } catch (_) {}
+  }
+  if (has("pytest.ini") || has("pyproject.toml") || has("setup.py") || has("tox.ini") || has("setup.cfg")) {
+    push(pytestCmd());
+  }
+  if (has("Cargo.toml")) push("cargo test");
+  if (has("go.mod")) push("go test ./...");
+  if (has("Gemfile")) push("bundle exec rspec");
+  if (has("composer.json")) push("./vendor/bin/phpunit");
+  if (has("pom.xml")) push("mvn -q test");
+  if (has("build.gradle") || has("build.gradle.kts")) push("./gradlew test");
+  if (has("pubspec.yaml")) push("dart test");
+  if (has("Package.swift")) push("swift test");
+
+  return out;
+}
+
 export function detectPolyglotStack(projectRoot = process.cwd()) {
   const edgeInfo = detectEdgeRuntime(projectRoot);
   const isDevcontainer = existsSync(join(projectRoot, ".devcontainer", "devcontainer.json"));

package/src/wizard-init.mjs

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { parseYaml, TIER_PRESETS, VENDOR_TIERS, FALLBACK_TIER } from "./config.mjs";
 import { suggestProvider, detectAvailableProviders } from "./provider-readiness.mjs";
 import { detectDefaultBranch } from "./git.mjs";
-import { resolveWorkspaceBoundary } from "./stack-detector.mjs";
+import { resolveWorkspaceBoundary, oracleCandidates } from "./stack-detector.mjs";
 import { PROFILE_NAMES, PROFILE_DESCRIPTIONS } from "./profiles.mjs";
 import { detectStackOracles, runVerificationProbe } from "./wizard-oracle.mjs";
 import { select, multiSelect, input, confirm, spinner, isTTY } from "./tui.mjs";
@@ -302,6 +302,51 @@ export function loadPresets(root = process.cwd()) {
  * @param {object} [options]
  * @returns {Promise<{ ok: boolean, configPath: string, plan: object }>}
  */
+/**
+ * Probe the chosen test command, and take detection's next choice if it fails.
+ *
+ * Runs on the non-interactive path too. `--yes` means "do not ask me", not
+ * "do not check" — and the user who is not watching is exactly the one who
+ * cannot notice that the command written into their config does not run.
+ * Before this, the probe lived inside the interactive branch, so
+ * `agentctl init --yes` wrote `make test` into a repository where `make test`
+ * exits 2 and `npm test` passes, and the first gate run was a hard red.
+ *
+ * @returns {Promise<string>} the command to save
+ */
+async function resolveRunnableOracle(root, testCmd, options = {}) {
+  if (!testCmd) return testCmd;
+  const probeSp = spinner(`Probing oracle: ${testCmd}`, options);
+  const probeRes = await runVerificationProbe(testCmd, root);
+  if (probeRes.ok) {
+    probeSp.stop(`Oracle verified successfully (${probeRes.durationMs}ms)`);
+    return testCmd;
+  }
+  probeSp.fail(`Oracle verification probe failed (Exit ${probeRes.code})`);
+
+  const alternates = oracleCandidates(root, testCmd).filter((c) => c !== testCmd).slice(0, 3);
+  for (const cand of alternates) {
+    const altSp = spinner(`Trying ${cand}`, options);
+    const altRes = await runVerificationProbe(cand, root);
+    if (altRes.ok) {
+      altSp.stop(`${cand} runs here (${altRes.durationMs}ms) — using it instead`);
+      return cand;
+    }
+    altSp.fail(`${cand} also failed (Exit ${altRes.code})`);
+  }
+
+  // Nothing runs. Say so in terms the user can act on, rather than leaving a
+  // failed spinner to scroll past and a broken command in the config.
+  const out = options.stdout || process.stdout;
+  out.write("\n");
+  out.write("   \u26a0\ufe0f  No test command could be run in this environment.\n");
+  out.write(`      Keeping "${testCmd}" \u2014 the gate will fail until it runs here.\n`);
+  out.write("      Point verify.test in .agent/config.yml at a command that works,\n");
+  out.write("      or, if this repository genuinely has no suite, set\n");
+  out.write("      verify.required: false deliberately rather than by accident.\n\n");
+  return testCmd;
+}
+
 export async function runInitWizard(root = process.cwd(), options = {}) {
   const interactive = options.interactive !== false && isTTY(options.stdin || process.stdin);
 
@@ -322,6 +367,7 @@ export async function runInitWizard(root = process.cwd(), options = {}) {
   let selectedProvider = options.provider || existingConfig.provider;
   let selectedProfile = options.profile || existingConfig.verify?.profile;
   let testCmd = options.testCmd;
+  let probeInteractive = null;
   let buildCmd = options.buildCmd;
   let selectedPresets = options.presets;
 
@@ -402,16 +448,20 @@ export async function runInitWizard(root = process.cwd(), options = {}) {
 
     selectedPresets = await multiSelect(presetOptions, "Select Autonomous Workflows to Enable", options);
 
-    const shouldProbe = await confirm("Run verification probe on test command before saving?", true, options);
-    if (shouldProbe && testCmd) {
-      const probeSp = spinner(`Probing oracle: ${testCmd}`, options);
-      const probeRes = await runVerificationProbe(testCmd, root);
-      if (probeRes.ok) {
-        probeSp.stop(`Oracle verified successfully (${probeRes.durationMs}ms)`);
-      } else {
-        probeSp.fail(`Oracle verification probe failed (Exit ${probeRes.code})`);
-      }
-    }
+    probeInteractive = await confirm("Run verification probe on test command before saving?", true, options);
+  }
+
+  // The probe runs whether or not anyone was asked: interactive users can
+  // decline it, but silence from `--yes` is not a decline.
+  if (probeInteractive !== false && options.probe !== false) {
+    // Resolve the command the way planInit will, or there is nothing to
+    // probe: on the headless path `testCmd` stays undefined until planInit
+    // fills it in from detection, so the probe silently examined nothing —
+    // the exact fail-open shape this project keeps finding in itself.
+    const effective =
+      testCmd || existingConfig.verify?.test || detectStackOracles(root)?.candidates?.testCmd || "";
+    const adopted = await resolveRunnableOracle(root, effective, options);
+    if (adopted) testCmd = adopted;
   }
 
   // `...options` first, for the same reason as in wizard-task.mjs: spreading it