claude-dev-env 1.72.0 → 1.73.0

package/rules/docstring-prose-matches-implementation.md

@@ -15,8 +15,9 @@ Read the body and the docstring side by side:
 - **Read-source / match-source unions.** A body that computes `read_names = a | b | c` (or any union of "what counts") names each union member in the prose enumeration. A union member the code applies but the prose omits is a gap.
 - **Suppressor / skip lists.** A body with several early returns that suppress the check names each suppressor in the prose.
 - **Shared fallback routes.** A summary that scopes a fallback call to one condition names every condition that reaches that call. When the body routes to the same fallback from two or more early-return guards (`if a is None: fallback(); return` and `if random() < p: fallback(); return`), the prose enumerates both guards. The `check_docstring_fallback_branch_coverage` gate blocks the single-condition form of this drift at Write/Edit time.
-- **Step order.** A docstring that says `A then B then C` matches the call order in the body.
+- **Step order.** A docstring that says `A then B then C` matches the call order in the body. A step enumeration that names the body's linear steps also names every corrective step the body guards inside an `if`/`elif` branch (`if not await cancel_and_reinitiate_update(...): return`). The `check_docstring_step_enumeration_dispatch_coverage` gate blocks the branch-guarded-dispatch form of this drift — a step-enumeration docstring that omits a two-or-more-token dispatch step the body guards inside a branch — at Write/Edit time.
 - **Predicate breadth.** A boolean helper whose prose promises a narrow check accepts only the inputs the prose names — no broader input class the name and prose do not mention.
+- **Exclusion-clause distinguisher.** A docstring sentence that says a named category of input "are not" / "is not" the thing the function flags (`plain logging, screenshot, or method-on-local calls inside a branch are not dispatch steps`) keys the exclusion to the same axis the body's classification keys on. When the body decides on one axis (a call sits in an `If.test` guard versus a plain statement) but the prose excludes on a different axis (the call's receiver shape — a method on a local), the exclusion clause names a category the body still flags: a guarded method-on-local call is flagged even though the prose lists method-on-local calls as excluded. Read the body's actual branch condition, then state the exclusion on that same axis (`plain (unguarded) calls inside a branch body are not dispatch steps`), so every member the prose excludes is a member the body also excludes.
 - **Companion-doc ordering and content claims.** A `SKILL.md` (or sibling `.md`) sentence that names a produced artifact and claims its order (`sorted`, `alphabetical`, `in sorted order`) or its content (`the at-risk names`, `just the current set`) matches the producer function's docstring and body for that same artifact. A producer that builds the artifact by merging stored names with new names and appending — preserving file order, not re-sorting the union — leaves a doc that still says `sorted` drifted on both counts: the order claim is wrong, and the content claim hides the merged-in prior entries. When the producer's ordering or union changes, the same change updates the companion doc. The two move together in one commit, even when the producer edit does not touch the `.md` file.
 
 When the body changes the set of behaviors it applies, the same edit updates the prose enumeration. The two move together in one commit.

package/skills/autoconverge/SKILL.md

@@ -23,6 +23,22 @@ the workflow journal.
 autoconverge runs it as a deterministic workflow. The two skills share the same
 helper scripts and the same convergence gate.
 
+## Run scope: one PR or several
+
+Decide the scope from how many PRs the user named, then follow that path:
+
+1. **One PR** → the single-PR run described below (`workflow/converge.mjs`): one
+   worktree, one workflow launch, one teardown.
+2. **Several PRs** → the [Multiple PRs](#multiple-prs) run
+   (`workflow/converge_multi.mjs`): one worktree per PR and a single workflow
+   launch that drives every PR's converge run in parallel, then one teardown per
+   PR.
+
+The single-PR sections (Requirements, Pre-flight, Run the workflow, Teardown)
+each describe one converge run. The Multiple PRs section reuses them once per PR
+and adds only what fanning out needs: a per-PR worktree and a per-PR teardown
+loop.
+
 ## Requirements
 
 Scan the tool list at the top of this conversation for the literal string
@@ -270,10 +286,87 @@ suite (`python -m pytest`) and keep scratch work in ephemeral temp dirs.
 - **Convergence check:** `check_convergence.py` is the authoritative gate; on a
   full pass the workflow marks `draft=false`.
 
+## Multiple PRs
+
+The multi-PR run drives several draft PRs to ready in one launch:
+`workflow/converge_multi.mjs` fans out one `converge.mjs` child run per PR with
+`parallel()`, and every child is pinned to its own PR's worktree through the
+`repoPath` it receives, so the children never share a checkout. Each child run is
+the exact single-PR convergence loop — same rounds, same reuse pass, same Copilot
+gate, same convergence check — one per PR at once. The children share the run's
+concurrency cap, so the fan-out self-throttles rather than spawning every PR's
+lenses at the same instant.
+
+### Multi-PR pre-flight (main session)
+
+`EnterWorktree` puts the session on one branch only, so the multi-PR path gives
+each PR its own checkout with `git worktree add`. For each PR the user named:
+
+1. **Resolve PR scope** as the single-PR pre-flight step 2 does: capture `owner`,
+   `repo`, `prNumber`, and `headRefName`; confirm the PR is a draft, and mark it
+   draft (`gh pr ready <n> --repo <o>/<r> --undo`) when it is already ready so the
+   loop owns the ready transition.
+2. **Create a worktree on the PR's head ref** and capture its absolute path. From
+   inside the PR's repository checkout:
+   `git worktree add <abs worktree path> <headRefName>` (run `git fetch origin
+   <headRefName>` first when the ref is not local). Put each PR's worktree under a
+   path carrying its PR number so the fan-out keeps them distinct. Confirm
+   `git -C <abs worktree path> rev-parse --abbrev-ref HEAD` equals the head ref
+   and its `HEAD` equals the PR head SHA.
+3. **Verify each worktree is the PR's repo (strict pre-flight):**
+   `python "$HOME/.claude/skills/_shared/pr-loop/scripts/preflight_worktree.py" --owner <owner> --repo <repo> --mode strict`,
+   run with that worktree as the working directory. A non-zero exit prints a
+   `PREFLIGHT_OUTCOME` line and an `ABORT` line: report it and drop that PR from
+   the run rather than aborting every PR.
+4. **Grant project permissions once per repository** — the single-PR pre-flight
+   step 4 grant covers every worktree of the same repo, so run it one time for
+   the repo the PRs live in.
+
+### Launch the multi-PR workflow
+
+Call the `Workflow` tool against the fan-out script, passing the absolute path of
+`converge.mjs` and one entry per PR:
+
+```
+Workflow({
+  scriptPath: "<this skill dir>/workflow/converge_multi.mjs",
+  args: {
+    convergeScriptPath: "<this skill dir>/workflow/converge.mjs",
+    prs: [
+      { owner: "<O>", repo: "<R>", prNumber: <N1>, repoPath: "<abs worktree 1>", bugbotDisabled: false },
+      { owner: "<O>", repo: "<R>", prNumber: <N2>, repoPath: "<abs worktree 2>", bugbotDisabled: false }
+    ]
+  }
+})
+```
+
+`convergeScriptPath` is the absolute path to `workflow/converge.mjs` in this same
+skill directory; each `repoPath` is the absolute path of the worktree that PR is
+checked out in. The workflow runs in the background and notifies this session on
+completion; watch live progress with `/workflows`, where each PR's child run
+appears under its own group.
+
+The workflow returns `{ converged, prCount, convergedCount, results, blocker }`,
+where `results` is one record per PR carrying
+`{ owner, repo, prNumber, converged, rounds, finalSha, blocker }`. The top-level
+`converged` is true only when every PR converged.
+
+### Multi-PR teardown (on workflow completion)
+
+Run the single-PR [Teardown](#teardown-on-workflow-completion) once per entry in
+`results`, using that PR's `owner`, `repo`, `prNumber`, and `finalSha`, and its
+own worktree as the working directory. Build and publish a PR's closing report
+only for a PR whose `converged` is true; for a PR that returned a blocker, skip
+its report and carry the blocker into the final summary. Revoke project
+permissions once per repository after every PR's teardown. Then print one summary
+report — a line per PR as
+`#<prNumber>: <converged | blocked> — rounds <N>, final <finalSha>[, blocker <blocker>]`.
+
 ## Folder map
 
 - `SKILL.md` — this hub.
 - `workflow/converge.mjs` — the convergence workflow script.
+- `workflow/converge_multi.mjs` — the multi-PR fan-out driver: one `converge.mjs` child run per PR in parallel, each pinned to its PR worktree via `repoPath`.
 - `workflow/aggregate_runs.py` — merges every autoconverge journal for a PR into one journal and returns its deduped findings, fix summaries, round count, and final SHA.
 - `workflow/convergence_summary.py` — builds the convergence-summary agent prompt over a PR's merged findings.
 - `workflow/render_report.py` — builds the closing convergence insights HTML report, taking the summary from `--summary-file`.

package/skills/autoconverge/workflow/converge.mjs

@@ -36,16 +36,40 @@ const HEADLESS_SAFETY_PREAMBLE =
   '- Keep scratch files and cleanup inside the OS temp dir or $CLAUDE_JOB_DIR/tmp (auto-allowed as ephemeral); never target a repository or worktree path with rm -rf.\n' +
   '- If a step appears to require a real destructive command, use a non-destructive equivalent or report it as a blocker instead of running it.\n\n'
 
+let activeRepoPath = null
+
+/**
+ * Build the per-agent worktree directive for a path-scoped run.
+ *
+ * A multi-PR parent run drives several converge children from one shared
+ * working directory, so each child pins its own agents to the worktree its PR
+ * is checked out in; without that pin every child's git, gh, diff, edit,
+ * commit, and test commands would run in the shared launch directory rather
+ * than the PR's own checkout. The parent hands the worktree path in as
+ * input.repoPath, which sets activeRepoPath. A single-PR run carries no
+ * repoPath, so this returns an empty string and every agent keeps its own
+ * working directory — behavior identical to a run with no path scoping.
+ * @param {string|null} repoPath the PR worktree absolute path, or null for the single-PR default
+ * @returns {string} the worktree directive to prepend, or an empty string when repoPath is null
+ */
+const worktreeDirective = (repoPath) =>
+  repoPath
+    ? `WORKTREE — this PR is checked out at ${repoPath}. Unless a step explicitly names a different repository directory (for example an environment-hardening repo checkout, which you cd into exactly as that step directs), run every git, gh, diff, edit, commit, push, and test command for this PR in that worktree: cd "${repoPath}" before any such command, and resolve repository roots from there.\n\n`
+    : ''
+
 /**
  * Spawn a workflow agent with the headless-safety preamble prepended to its
  * prompt. Every agent in this convergence loop runs unattended, so each one is
- * routed through here to inherit the same no-confirmation-prompt guidance.
+ * routed through here to inherit the same no-confirmation-prompt guidance. On a
+ * path-scoped run the worktree directive is prepended too, so every agent runs
+ * in the PR's own worktree (activeRepoPath); on a single-PR run that directive
+ * is empty and the agent keeps its own working directory.
  * @param {string} prompt the agent's role-specific instruction body
  * @param {object} options the agent() options (label, phase, schema, agentType, model)
  * @returns {Promise<*>} the agent() result
  */
 const convergeAgent = (prompt, options) =>
-  agent(`${HEADLESS_SAFETY_PREAMBLE}${prompt}`, options)
+  agent(`${HEADLESS_SAFETY_PREAMBLE}${worktreeDirective(activeRepoPath)}${prompt}`, options)
 
 const PRE_COMMIT_GATE_STEP =
   `\n\nFINAL STEP — pre-commit gate check (do NOT commit): before your turn ends, prove your working-tree changes CAN be committed by dry-running the CODE_RULES commit gate that gates git commit (precommit_code_rules_gate). From inside the checkout that holds your changes, resolve its root with git rev-parse --show-toplevel, stage your changes with git add -A, then run exactly:\n` +
@@ -696,6 +720,7 @@ if (runInput.blocker) {
   return { converged: false, rounds: 0, finalSha: null, blocker: runInput.blocker }
 }
 const input = runInput.input
+activeRepoPath = typeof input.repoPath === 'string' && input.repoPath ? input.repoPath : null
 const prCoordinates = `owner=${input.owner} repo=${input.repo} PR #${input.prNumber} (https://github.com/${input.owner}/${input.repo}/pull/${input.prNumber})`
 
 /**

package/skills/autoconverge/workflow/converge.path-aware.test.mjs

@@ -0,0 +1,47 @@
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const workflowDirectory = dirname(fileURLToPath(import.meta.url));
+const convergeSource = readFileSync(join(workflowDirectory, 'converge.mjs'), 'utf8');
+
+function sliceBetween(startNeedle, endNeedle) {
+  const sliceStart = convergeSource.indexOf(startNeedle);
+  assert.notEqual(sliceStart, -1, `expected ${startNeedle} to exist`);
+  const sliceEnd = convergeSource.indexOf(endNeedle, sliceStart + startNeedle.length);
+  assert.notEqual(sliceEnd, -1, `expected ${endNeedle} to exist after ${startNeedle}`);
+  return convergeSource.slice(sliceStart, sliceEnd);
+}
+
+const productionModule = new Function(
+  `${sliceBetween('const worktreeDirective =', '\nconst convergeAgent =')}\n` +
+    'return { worktreeDirective };',
+)();
+const { worktreeDirective } = productionModule;
+
+test('a single-PR run (no repoPath) produces an empty worktree directive', () => {
+  assert.equal(worktreeDirective(null), '');
+});
+
+test('a path-scoped run pins every agent to the PR worktree by absolute path', () => {
+  const directive = worktreeDirective('/worktrees/pr-398');
+  assert.match(directive, /\/worktrees\/pr-398/);
+  assert.match(directive, /cd /);
+  assert.match(directive, /git, gh, diff, edit, commit, push, and test/);
+});
+
+test('a path-scoped run defers to a step that names a different repository directory', () => {
+  assert.match(worktreeDirective('/worktrees/pr-398'), /different repository directory/i);
+});
+
+test('convergeAgent prepends the worktree directive for the active repo path', () => {
+  const agentDefinition = sliceBetween('const convergeAgent =', '\nconst PRE_COMMIT_GATE_STEP');
+  assert.match(agentDefinition, /worktreeDirective\(activeRepoPath\)/);
+  assert.match(agentDefinition, /HEADLESS_SAFETY_PREAMBLE/);
+});
+
+test('the run binds activeRepoPath from input.repoPath after the input is parsed', () => {
+  assert.match(convergeSource, /activeRepoPath = typeof input\.repoPath === 'string'/);
+});

package/skills/autoconverge/workflow/converge_multi.mjs

@@ -0,0 +1,161 @@
+/**
+ * Autoconverge multi-PR fan-out workflow driver.
+ *
+ * SINGLE-FILE CONTRACT — keep this file self-contained. The Workflow runtime
+ * wraps this body in a function (so top-level await and return work) and rejects
+ * static import statements, and `export const meta` must be the first statement.
+ * This driver fans out one converge.mjs child run per PR with parallel(); the
+ * converge.mjs child uses only agent()/parallel() (never workflow()), so the
+ * one-level workflow() nesting limit holds.
+ */
+
+export const meta = {
+  name: 'autoconverge-multi',
+  description: 'Drive several draft PRs to convergence in one run: fan out one autoconverge converge.mjs child per PR in parallel, each pinned to its own checked-out worktree via repoPath, then report every PR\'s outcome together.',
+  whenToUse: 'Launched by the /autoconverge skill when the user names more than one PR to converge at once; the single-PR path launches workflow/converge.mjs directly.',
+  phases: [
+    { title: 'Converge all', detail: 'One converge.mjs child run per PR, all in parallel; each child is pinned to its own PR worktree through repoPath' },
+  ],
+}
+
+/**
+ * Normalize the workflow args global into a parsed object.
+ *
+ * The Workflow runtime may deliver args as a JSON-encoded string or as an
+ * object; a string is parsed and an object passes through unchanged. A non-JSON
+ * or empty string yields null so a malformed payload becomes a structured
+ * blocker rather than aborting the run.
+ * @param {string|object} rawArgs the workflow args global (JSON string or object)
+ * @returns {object|null} the parsed args, or null when a string payload fails to parse
+ */
+function normalizeMultiInput(rawArgs) {
+  if (typeof rawArgs !== 'string') return rawArgs
+  try {
+    return JSON.parse(rawArgs)
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Decide whether one PR entry carries every coordinate a child run needs.
+ *
+ * A child converge run needs the PR's owner, repo, and number to address its
+ * GitHub calls, and the absolute worktree path the PR is checked out in to pin
+ * its agents there.
+ * @param {object} prEntry one element of the args.prs array
+ * @returns {boolean} true when owner, repo, prNumber, and a non-empty string repoPath are all present
+ */
+function isUsablePrEntry(prEntry) {
+  return (
+    prEntry != null &&
+    Boolean(prEntry.owner) &&
+    Boolean(prEntry.repo) &&
+    Boolean(prEntry.prNumber) &&
+    typeof prEntry.repoPath === 'string' &&
+    Boolean(prEntry.repoPath)
+  )
+}
+
+/**
+ * Validate the normalized multi-PR input into usable coordinates or a blocker.
+ *
+ * A fan-out run needs the absolute converge.mjs script path and a non-empty list
+ * of PR entries that each carry owner, repo, prNumber, and the absolute worktree
+ * path the PR is checked out in. A payload that fails to parse, a non-string
+ * convergeScriptPath, a missing or empty prs list, or any entry missing a
+ * coordinate yields a blocker the top-level run reports as
+ * {converged:false, blocker} rather than throwing on a missing field.
+ * @param {string|object} rawArgs the workflow args global (JSON string or object)
+ * @returns {{input: object|null, blocker: string|null}} usable coordinates or a blocker
+ */
+function classifyMultiInput(rawArgs) {
+  const candidate = normalizeMultiInput(rawArgs)
+  if (candidate == null) {
+    return {
+      input: null,
+      blocker: 'invalid run coordinates: the workflow args did not parse into an object',
+    }
+  }
+  if (typeof candidate.convergeScriptPath !== 'string' || !candidate.convergeScriptPath) {
+    return {
+      input: null,
+      blocker:
+        'invalid run coordinates: convergeScriptPath (absolute path to converge.mjs) is required',
+    }
+  }
+  if (!Array.isArray(candidate.prs) || candidate.prs.length === 0) {
+    return {
+      input: null,
+      blocker: 'invalid run coordinates: prs must be a non-empty array of PR entries',
+    }
+  }
+  const unusableEntryCount = candidate.prs.filter(
+    (eachEntry) => !isUsablePrEntry(eachEntry),
+  ).length
+  if (unusableEntryCount > 0) {
+    return {
+      input: null,
+      blocker: `invalid run coordinates: ${unusableEntryCount} PR entry/entries missing owner, repo, prNumber, or repoPath`,
+    }
+  }
+  return { input: candidate, blocker: null }
+}
+
+const multiInput = classifyMultiInput(args)
+if (multiInput.blocker) {
+  return { converged: false, prCount: 0, convergedCount: 0, results: [], blocker: multiInput.blocker }
+}
+const input = multiInput.input
+
+phase('Converge all')
+log(`autoconverge multi-PR: driving ${input.prs.length} PR(s) to ready in parallel`)
+
+const childResults = await parallel(
+  input.prs.map((eachPr) => async () => {
+    const childOutcome = await workflow(
+      { scriptPath: input.convergeScriptPath },
+      {
+        owner: eachPr.owner,
+        repo: eachPr.repo,
+        prNumber: eachPr.prNumber,
+        repoPath: eachPr.repoPath,
+        bugbotDisabled: Boolean(eachPr.bugbotDisabled),
+      },
+    )
+    return {
+      owner: eachPr.owner,
+      repo: eachPr.repo,
+      prNumber: eachPr.prNumber,
+      converged: Boolean(childOutcome && childOutcome.converged),
+      rounds: childOutcome && childOutcome.rounds !== undefined ? childOutcome.rounds : null,
+      finalSha: childOutcome && childOutcome.finalSha !== undefined ? childOutcome.finalSha : null,
+      blocker: childOutcome && childOutcome.blocker !== undefined ? childOutcome.blocker : null,
+    }
+  }),
+)
+
+const results = childResults.map((eachResult, eachIndex) =>
+  eachResult === null
+    ? {
+        owner: input.prs[eachIndex].owner,
+        repo: input.prs[eachIndex].repo,
+        prNumber: input.prs[eachIndex].prNumber,
+        converged: false,
+        rounds: null,
+        finalSha: null,
+        blocker: 'child run threw or was skipped before returning an outcome',
+      }
+    : eachResult,
+)
+
+const convergedCount = results.filter((eachResult) => eachResult.converged).length
+log(`autoconverge multi-PR done: ${convergedCount}/${results.length} PR(s) converged`)
+
+return {
+  converged: convergedCount === results.length,
+  prCount: results.length,
+  convergedCount,
+  results,
+  blocker: null,
+}

package/skills/autoconverge/workflow/converge_multi.run-input.test.mjs

@@ -0,0 +1,100 @@
+import { test } from 'node:test';
+import { strict as assert } from 'node:assert';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+
+const workflowDirectory = dirname(fileURLToPath(import.meta.url));
+const multiSource = readFileSync(join(workflowDirectory, 'converge_multi.mjs'), 'utf8');
+
+function sourceSliceBetween(startNeedle, endNeedle) {
+  const sliceStart = multiSource.indexOf(startNeedle);
+  assert.notEqual(sliceStart, -1, `expected ${startNeedle} to exist`);
+  const sliceEnd = multiSource.indexOf(endNeedle, sliceStart + startNeedle.length);
+  assert.notEqual(sliceEnd, -1, `expected ${endNeedle} to exist after ${startNeedle}`);
+  return multiSource.slice(sliceStart, sliceEnd);
+}
+
+const productionModule = new Function(
+  `${sourceSliceBetween('function normalizeMultiInput(', '\nconst multiInput =')}\n` +
+    'return { normalizeMultiInput, isUsablePrEntry, classifyMultiInput };',
+)();
+const { normalizeMultiInput, classifyMultiInput } = productionModule;
+
+const SCRIPT_PATH = '/abs/skills/autoconverge/workflow/converge.mjs';
+
+function validEntry(prNumber) {
+  return {
+    owner: 'JonEcho',
+    repo: 'python-automation',
+    prNumber,
+    repoPath: `/worktrees/pr-${prNumber}`,
+  };
+}
+
+function validArgs() {
+  return { convergeScriptPath: SCRIPT_PATH, prs: [validEntry(398), validEntry(402)] };
+}
+
+test('an object payload passes through unchanged', () => {
+  const parsed = validArgs();
+  assert.deepEqual(normalizeMultiInput(parsed), parsed);
+});
+
+test('a JSON-encoded string payload is parsed into coordinates', () => {
+  assert.deepEqual(normalizeMultiInput(JSON.stringify(validArgs())), validArgs());
+});
+
+test('a non-JSON string returns null rather than throwing', () => {
+  assert.equal(normalizeMultiInput('not json at all'), null);
+});
+
+test('valid coordinates classify with no blocker and keep every PR entry', () => {
+  const classified = classifyMultiInput(validArgs());
+  assert.equal(classified.blocker, null);
+  assert.equal(classified.input.prs.length, 2);
+});
+
+test('a missing convergeScriptPath is blocked', () => {
+  const classified = classifyMultiInput({ prs: [validEntry(398)] });
+  assert.equal(classified.input, null);
+  assert.match(classified.blocker, /convergeScriptPath/);
+});
+
+test('an empty prs array is blocked', () => {
+  const classified = classifyMultiInput({ convergeScriptPath: SCRIPT_PATH, prs: [] });
+  assert.equal(classified.input, null);
+  assert.match(classified.blocker, /non-empty array/);
+});
+
+test('a missing prs list is blocked', () => {
+  const classified = classifyMultiInput({ convergeScriptPath: SCRIPT_PATH });
+  assert.equal(classified.input, null);
+  assert.match(classified.blocker, /non-empty array/);
+});
+
+test('a non-array prs value is blocked', () => {
+  const classified = classifyMultiInput({ convergeScriptPath: SCRIPT_PATH, prs: 'nope' });
+  assert.equal(classified.input, null);
+  assert.match(classified.blocker, /non-empty array/);
+});
+
+test('an entry missing prNumber is blocked', () => {
+  const badEntry = { owner: 'JonEcho', repo: 'python-automation', repoPath: '/w/x' };
+  const classified = classifyMultiInput({ convergeScriptPath: SCRIPT_PATH, prs: [badEntry] });
+  assert.equal(classified.input, null);
+  assert.match(classified.blocker, /missing/);
+});
+
+test('an entry missing repoPath is blocked', () => {
+  const badEntry = { owner: 'JonEcho', repo: 'python-automation', prNumber: 398 };
+  const classified = classifyMultiInput({ convergeScriptPath: SCRIPT_PATH, prs: [badEntry] });
+  assert.equal(classified.input, null);
+  assert.match(classified.blocker, /missing/);
+});
+
+test('a null payload is blocked', () => {
+  const classified = classifyMultiInput('not json at all');
+  assert.equal(classified.input, null);
+  assert.match(classified.blocker, /did not parse/);
+});