jules-orchestrator-kit 0.70.0 → 0.72.0

package/src/ops/command-registry.mjs

@@ -543,6 +543,115 @@ export const COMMAND_REGISTRY = [
       { name: "json", type: "boolean", description: "Output JSON structured bootstrap result (-j)" },
     ],
   },
+  {
+    id: "pr-harvest",
+    path: ["pr", "harvest"],
+    title: "pr harvest",
+    description: "Scan, audit and auto-merge verified agent pull requests",
+    category: "Operate",
+    mutates: true,
+    risk: "moderate",
+    interactive: "never",
+    requiresRepository: true,
+    shortcuts: ["harvest", "pr"],
+    examples: [
+      "agentctl pr harvest",
+      "agentctl pr harvest --auto",
+      "agentctl pr harvest --dry-run",
+      "agentctl pr harvest --json",
+    ],
+    flags: [
+      { name: "tier", type: "string", description: "Filter PRs by tier label" },
+      { name: "limit", type: "string", description: "Maximum PRs to harvest" },
+      { name: "auto", type: "boolean", description: "Automatically merge qualifying green PRs" },
+      { name: "merge", type: "boolean", description: "Merge matching PRs" },
+      { name: "allow-no-checks", type: "boolean", description: "Allow PR merge when no CI checks are configured" },
+      { name: "dry-run", type: "boolean", description: "Simulate PR harvest without merging (-d)" },
+      { name: "json", type: "boolean", description: "Output structured JSON harvest report (-j)" },
+    ],
+  },
+  {
+    id: "session-get",
+    path: ["session", "get"],
+    title: "session get",
+    description: "Retrieve remote execution status for a session ID",
+    category: "Inspect",
+    mutates: false,
+    risk: "low",
+    interactive: "never",
+    requiresRepository: true,
+    shortcuts: ["session status", "session"],
+    examples: [
+      "agentctl session get <sessionId>",
+      "agentctl session get <sessionId> --dry-run",
+      "agentctl session get <sessionId> --json",
+    ],
+    flags: [
+      { name: "dry-run", type: "boolean", description: "Simulate session retrieval (-d)" },
+      { name: "json", type: "boolean", description: "Output structured JSON session data (-j)" },
+    ],
+  },
+  {
+    id: "plan-approve",
+    path: ["plan", "approve"],
+    title: "plan approve",
+    description: "Approve a pending execution plan for an agent session",
+    category: "Operate",
+    mutates: true,
+    risk: "moderate",
+    interactive: "never",
+    requiresRepository: true,
+    shortcuts: ["approve", "plan"],
+    examples: [
+      "agentctl plan approve <sessionId>",
+      "agentctl plan approve <sessionId> --dry-run",
+      "agentctl approve <sessionId>",
+    ],
+    flags: [
+      { name: "dry-run", type: "boolean", description: "Simulate plan approval (-d)" },
+      { name: "json", type: "boolean", description: "Output structured JSON result (-j)" },
+    ],
+  },
+  {
+    id: "lock",
+    path: ["lock"],
+    title: "lock",
+    description: "Multi-agent coordination locks: acquire, release, or view file status",
+    category: "Operate",
+    mutates: true,
+    risk: "low",
+    interactive: "never",
+    requiresRepository: true,
+    shortcuts: [],
+    examples: [
+      "agentctl lock status",
+      "agentctl lock acquire agent-1 task-1 src/main.js",
+      "agentctl lock release task-1",
+    ],
+    flags: [
+      { name: "json", type: "boolean", description: "Output structured JSON result (-j)" },
+    ],
+  },
+  {
+    id: "evidence",
+    path: ["evidence"],
+    title: "evidence",
+    description: "Inspect and verify cryptographic evidence manifests",
+    category: "Inspect",
+    mutates: false,
+    risk: "low",
+    interactive: "never",
+    requiresRepository: true,
+    shortcuts: [],
+    examples: [
+      "agentctl evidence status",
+      "agentctl evidence verify",
+      "agentctl evidence export --json",
+    ],
+    flags: [
+      { name: "json", type: "boolean", description: "Output structured JSON result (-j)" },
+    ],
+  },
 ];
 
 /**

package/src/ops/test-collection.mjs

@@ -33,8 +33,7 @@ const COUNT_PATTERNS = [
   // pytest — "collected 12 items", "12 passed", "no tests ran in 0.01s"
   { name: "pytest", re: /^\s*collected\s+(\d+)\s+items?/m },
   { name: "pytest", re: /=+\s*(\d+)\s+passed/m },
-  // cargo — "running 7 tests"
-  { name: "cargo", re: /^\s*running\s+(\d+)\s+tests?\s*$/m },
+  // Cargo multi-target output is aggregated above COUNT_PATTERNS (F15)
   // jest / vitest — "Tests:       12 passed, 12 total"
   { name: "jest", re: /^\s*Tests:\s+.*?(\d+)\s+total\s*$/m },
   // mocha — "12 passing"
@@ -88,10 +87,13 @@ const EXPLICIT_ZERO = [
   { name: "gradle", re: /^>\s*Task\s+:\S*test\S*\s+NO-SOURCE\s*$/mi },
   { name: "ctest", re: /\bNo tests were found\b/i },
   { name: "flutter", re: /\bNo tests ran\.?/i },
+  { name: "go", re: /\[no tests to run\]/ },
 ];
 
 /** Go prints this per package that has no test files at all. */
 const GO_NO_TEST_FILES = /\[no test files\]/;
+/** Go prints this when test files exist but test selection (-run) matched nothing. */
+const GO_NO_TESTS_TO_RUN = /\[no tests to run\]/;
 /**
  * Any sign that a Go package did run tests.
  *
@@ -111,10 +113,78 @@ const GO_RAN_SOMETHING = /^(?:(?:ok|FAIL)\s+(?!\d+\s)\S+|---\s+(?:PASS|FAIL|SKIP
  *   `count` is null when no recognised runner stated one — which is not a
  *   finding, only an absence of evidence.
  */
+/**
+ * Did the command write nothing at all, on either stream?
+ *
+ * This is the one absence that is evidence rather than the lack of it. The
+ * one-sided floor exists because an unrecognised runner states no count, and
+ * hard-redding every runner not on the list would be worse than the hole it
+ * closes. But an unrecognised runner still *prints*: dots, a summary line,
+ * a package name, something. Zero bytes on both streams is not a dialect the
+ * list has yet to learn — it is a command that ran nothing.
+ *
+ * `pnpm -r test` on a workspace whose packages declare no test script is the
+ * shape that made this necessary: it exits 0, writes nothing anywhere, and
+ * was indistinguishable from a full suite by every signal the gate had.
+ *
+ * Resolved here and consumed in two places — the gate's floor and `init`'s
+ * oracle probe — because writing the rule once in each is how this project
+ * has repeatedly ended up with two answers to one question.
+ */
+export function producedNoOutput(stdout = "", stderr = "") {
+  return `${stdout || ""}${stderr || ""}`.trim() === "";
+}
+
+/**
+ * Does this command claim to run a test suite?
+ *
+ * Silence alone cannot carry the verdict, and the first version of this rule
+ * assumed it could. `node --check index.js`, `tsc --noEmit`, `go vet ./...`
+ * and `python3 -m compileall -q .` all exit 0 having printed nothing — and
+ * they are honest static gates, two of which this kit writes itself for
+ * repositories that have no suite yet. Failing on silence alone hard-redded
+ * every one of them, which is the same first-run rejection of correct code
+ * that the whole collection floor is careful to avoid.
+ *
+ * Nothing in the *output* separates `pnpm -r test` from `tsc --noEmit`; both
+ * are empty. The difference is in what the command says it is. So this reads
+ * the command, the same way `isPlaceholderTestScript` does: a command that is
+ * recognisably a suite invocation and printed nothing ran no suite, while a
+ * static checker that printed nothing did exactly what it promised.
+ *
+ * One-sided in the safe direction, like everything else here. An unrecognised
+ * command is not treated as a suite, so an unusual runner keeps its advisory
+ * pass rather than becoming a hard red.
+ */
+const TEST_SUITE_COMMAND =
+  /(?:^|\s|\/)(?:pytest|jest|vitest|mocha|ava|karma|jasmine|nyc|c8|tap|tape|rspec|minitest|phpunit|behave|nose2?|ginkgo|gotestsum|nextest)\b|\b(?:go|cargo|swift|dart|flutter|deno|bun|dotnet|mix|lein|sbt|gradlew?|mvn)\s+test\b|\bunittest\b|-m\s+(?:pytest|unittest)\b|\bnode\s+--test\b|(?:^|&&|;|\|)\s*(?:npm|pnpm|yarn|bun|npx)\b[^&;|]*?\btest\b/;
+
+export function looksLikeTestSuiteCommand(cmd) {
+  return typeof cmd === "string" && TEST_SUITE_COMMAND.test(cmd);
+}
+
 export function parseCollectedTests(stdout = "", stderr = "") {
   const text = `${stdout || ""}\n${stderr || ""}`;
   if (!text.trim()) return { count: null, runner: null };
 
+  // Pytest --collect-only states "collected N items" and "N tests collected",
+  // but executed 0 tests. A run that executed tests reports passed/failed/skipped.
+  if (
+    /=+\s*\d+\s+tests? collected\b/i.test(text) &&
+    !/=+\s*.*?(?:\d+\s+(?:passed|failed|skipped))\b/i.test(text)
+  ) {
+    return { count: 0, runner: "pytest" };
+  }
+
+  // Cargo states "running N tests" per target (lib, bin, integration tests, doc tests).
+  // A multi-target run with 0 unit tests and 58 integration tests must aggregate all
+  // targets rather than stopping at the first target-local zero (F15).
+  const cargoMatches = [...text.matchAll(/^\s*running\s+(\d+)\s+tests?\s*$/gm)];
+  if (cargoMatches.length > 0) {
+    const totalCargoTests = cargoMatches.reduce((sum, m) => sum + Number(m[1]), 0);
+    return { count: totalCargoTests, runner: "cargo" };
+  }
+
   // A stated count wins over a phrase that merely resembles one.
   //
   // `EXPLICIT_ZERO` used to be consulted first, so any output containing the
@@ -133,7 +203,13 @@ export function parseCollectedTests(stdout = "", stderr = "") {
 
   // Go states absence per package rather than as a count, so it needs its own
   // pass before the generic patterns.
-  if (GO_NO_TEST_FILES.test(text) || GO_RAN_SOMETHING.test(text)) {
+  if (GO_NO_TEST_FILES.test(text) || GO_NO_TESTS_TO_RUN.test(text) || GO_RAN_SOMETHING.test(text)) {
+    const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
+    const pkgLines = lines.filter((l) => /^(?:ok|FAIL|\?)\s+/.test(l));
+    const allEmpty =
+      pkgLines.length > 0 &&
+      pkgLines.every((l) => GO_NO_TEST_FILES.test(l) || GO_NO_TESTS_TO_RUN.test(l));
+    if (allEmpty) return { count: 0, runner: "go" };
     // Only a run where *no* package did anything is a zero: a monorepo where
     // one package has no tests and three do is a normal, healthy repository.
     if (!GO_RAN_SOMETHING.test(text)) return { count: 0, runner: "go" };
@@ -168,6 +244,30 @@ export function checkCollectionFloor(testResult, opts = {}) {
     return { ok: true, count: null, runner: null, reason: null };
   }
 
+  // A command that says it runs a suite, and printed nothing, ran no suite.
+  //
+  // Both halves are required. Silence alone would hard-red `tsc --noEmit` and
+  // `python3 -m compileall`, which are honest static gates this kit generates
+  // itself; the command shape alone would say nothing, because a real suite
+  // prints. Together they are decidable, and they are exactly `pnpm -r test`
+  // on a workspace whose packages declare no test script.
+  if (looksLikeTestSuiteCommand(testResult.command) && producedNoOutput(testResult.stdout, testResult.stderr)) {
+    return {
+      ok: false,
+      count: 0,
+      runner: null,
+      silent: true,
+      reason:
+        `The verification command ${testResult.command ? `${JSON.stringify(testResult.command)} ` : ""}` +
+        `exited 0 and wrote nothing at all — no test names, no summary, no count. ` +
+        `Every test runner prints something, so this command ran no suite, and approving this change ` +
+        `would certify nothing. A workspace command such as \`pnpm -r test\` does this when no package ` +
+        `declares a test script. Point verify.test at the suite that covers this repository ` +
+        `(often the root script rather than the recursive one), or — if this repository intentionally ` +
+        `uses only the scope and secret phases — set verify.required: false, which says so on the record.`,
+    };
+  }
+
   const { count, runner } = parseCollectedTests(testResult.stdout, testResult.stderr);
 
   // Deliberately one-sided: only a *stated* zero fails, because failing on