claude-code-session-manager 0.79.0 → 0.81.0

package/src/main/__tests__/scheduler-autofix-outcome.test.cjs

@@ -10,6 +10,13 @@
  * coverage in scheduler-autofix-select.test.cjs (node --test) exercises the
  * same helpers in more granular detail.
  *
+ * PRD 1129 added one sub-shape to case (d): "outcome 'plan' WITH a queue
+ * row is neither retried nor annotated" only holds while that queue row
+ * (the fix-plan child) is still alive. Once the child itself reaches a
+ * terminal, non-completed status, isFixPlanDead makes the parent eligible
+ * for exactly one further attempt (stamped autoFixReopened: true), after
+ * which it is permanently excluded and annotated again.
+ *
  * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-autofix-outcome.test.cjs
  */
 
@@ -17,7 +24,7 @@
 
 import { test, expect } from 'vitest';
 const {
-  selectAutoFixTargets, isExhaustedAutoFix, isPlanUnqueued, fixSlugFor,
+  selectAutoFixTargets, isExhaustedAutoFix, isPlanUnqueued, isFixPlanDead, fixSlugFor,
 } = require('../scheduler.cjs');
 
 const noSiblingOnDisk = () => false;
@@ -82,6 +89,71 @@ test("(d) outcome 'plan' with the fix slug present in the queue is neither retri
   expect(isAnnotatable(job, queuedSlugs)).toBe(false);
 });
 
+// (e) dead fix-plan child: outcome 'plan' whose fix-plan row itself died —
+// the parent is eligible again, exactly once.
+test('(e) a dead fix-plan child makes the parent eligible for one further attempt', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
+  const deadChild = { slug: fixSlugFor(job), status: 'needs_review', parallelGroup: job.parallelGroup };
+  const jobs = [job, deadChild];
+  expect(isFixPlanDead(job, jobs)).toBe(true);
+  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(true);
+  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(false);
+});
+
+test('(e) a failed, quarantined, or skipped fix-plan child also counts as dead', () => {
+  for (const status of ['failed', 'quarantined', 'skipped']) {
+    const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
+    const deadChild = { slug: fixSlugFor(job), status, parallelGroup: job.parallelGroup };
+    expect(isFixPlanDead(job, [job, deadChild])).toBe(true);
+  }
+});
+
+test('(e) an already-reopened parent is annotated, never eligible again — even with another dead child', () => {
+  const job = makeJob({
+    autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 1, autoFixReopened: true,
+  });
+  const deadChild = { slug: fixSlugFor(job), status: 'needs_review', parallelGroup: job.parallelGroup };
+  const jobs = [job, deadChild];
+  expect(isFixPlanDead(job, jobs)).toBe(false);
+  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
+  expect(isExhaustedAutoFix(job)).toBe(true);
+  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(true);
+});
+
+test('(e) a reopened parent whose second attempt is still in flight (outcome cleared) is untouched — not re-eligible, not yet annotated', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixRetries: 1, autoFixReopened: true });
+  expect(isFixPlanDead(job, [job])).toBe(false);
+  expect(selectAutoFixTargets([job], { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
+  expect(isExhaustedAutoFix(job)).toBe(false);
+});
+
+test('(e) a fix-plan child that is still pending leaves the parent untouched', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
+  const pendingChild = { slug: fixSlugFor(job), status: 'pending', parallelGroup: job.parallelGroup };
+  const jobs = [job, pendingChild];
+  expect(isFixPlanDead(job, jobs)).toBe(false);
+  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
+  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(false);
+});
+
+test('(e) a fix-plan child that is still running leaves the parent untouched', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
+  const runningChild = { slug: fixSlugFor(job), status: 'running', parallelGroup: job.parallelGroup };
+  const jobs = [job, runningChild];
+  expect(isFixPlanDead(job, jobs)).toBe(false);
+  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
+  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(false);
+});
+
+test('(e) a fix-plan child that completed leaves the parent untouched (unchanged from today)', () => {
+  const job = makeJob({ autoFixAttempted: true, autoFixOutcome: 'plan', autoFixRetries: 0 });
+  const completedChild = { slug: fixSlugFor(job), status: 'completed', parallelGroup: job.parallelGroup };
+  const jobs = [job, completedChild];
+  expect(isFixPlanDead(job, jobs)).toBe(false);
+  expect(selectAutoFixTargets(jobs, { fixSlugExists: noSiblingOnDisk }).some((j) => j.slug === job.slug)).toBe(false);
+  expect(isAnnotatable(job, new Set(jobs.map((j) => j.slug)))).toBe(false);
+});
+
 // (invariant) every needs_review job is either an auto-fix target or
 // annotatable (would receive a non-null verifierVerdict) — never both false.
 test('invariant: fresh, retry-eligible, exhausted, and plan-unqueued jobs are always selected or annotatable', () => {

package/src/main/__tests__/scheduler-autofix-select.test.cjs

@@ -308,6 +308,23 @@ test('isFixPlanBeyondDepthCap: fix-plan at depth 1 is not capped, depth 2 is', (
   assert.strictEqual(isFixPlanBeyondDepthCap('05-fix-foo', MAX_INVESTIGATION_DEPTH + 1), true);
 });
 
+// PRD 1131: classification is now provenance-aware (isFixPlan), not slug-only.
+// A legacy row with no `isFixPlan` argument at all still falls back to the
+// slug-only heuristic above (no re-classification of live history).
+
+test('isFixPlanBeyondDepthCap: a scheduler-authored fix plan (isFixPlan:true) is still classified as one and capped at the same depth', () => {
+  assert.strictEqual(isFixPlanBeyondDepthCap('05-fix-foo', MAX_INVESTIGATION_DEPTH, true), false);
+  assert.strictEqual(isFixPlanBeyondDepthCap('05-fix-foo', MAX_INVESTIGATION_DEPTH + 1, true), true);
+});
+
+test('isFixPlanBeyondDepthCap: a human-authored PRD (isFixPlan:false) whose slug merely matches "fix-" is never capped, even with no investigationDepth (PRD 1126 regression)', () => {
+  assert.strictEqual(isFixPlanBeyondDepthCap('126-fix-plan-death-reopens-parent', undefined, false), false);
+});
+
+test('isFixPlanBeyondDepthCap: a legacy row (isFixPlan argument omitted/undefined) with a fix- slug and no depth field is still treated as a fix plan via the slug fallback', () => {
+  assert.strictEqual(isFixPlanBeyondDepthCap('05-fix-foo', undefined, undefined), true);
+});
+
 test('healTargetForFix: depth-2 fix-of-a-fix slug resolves back to the depth-1 fix job (521-fix-recorder-export-footer-redesign)', () => {
   // Depth-1 fix job: originally authored to fix job 521, itself in needs_review.
   const depth1FixJob = {

package/src/main/__tests__/scheduler-blocked-by-foreign-wip.test.cjs

@@ -0,0 +1,107 @@
+/**
+ * scheduler-blocked-by-foreign-wip.test.cjs — validateForeignWipBlockClaim
+ * (the manifest-membership check that stops an executor from laundering a
+ * real regression into a BLOCKED_BY_FOREIGN_WIP verdict) and
+ * requeueForeignWipBlockedJobs (reconcile()'s auto-clear-and-resume pass).
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-blocked-by-foreign-wip.test.cjs
+ */
+
+'use strict';
+
+import { test, expect } from 'vitest';
+const {
+  validateForeignWipBlockClaim,
+  requeueForeignWipBlockedJobs,
+  FOREIGN_WIP_BLOCK_STREAK_LIMIT,
+} = require('../scheduler.cjs');
+
+// ─── validateForeignWipBlockClaim ──────────────────────────────────────────
+
+test('validateForeignWipBlockClaim: ok when every claimed path is in preRunDirtyPaths', () => {
+  const job = { preRunDirtyPaths: ['src/a.ts', 'src/b.ts'] };
+  const v = validateForeignWipBlockClaim(['src/a.ts'], job);
+  expect(v.ok).toBe(true);
+  expect(v.validPaths).toEqual(['src/a.ts']);
+  expect(v.invalidPaths).toEqual([]);
+});
+
+test('validateForeignWipBlockClaim: ok when every claimed path is in carriedPaths', () => {
+  const job = { carriedPaths: ['config/settings.json'] };
+  const v = validateForeignWipBlockClaim(['config/settings.json'], job);
+  expect(v.ok).toBe(true);
+  expect(v.validPaths).toEqual(['config/settings.json']);
+});
+
+test('validateForeignWipBlockClaim: rejects an unlisted path — the launder-a-regression case', () => {
+  // The job's real, disclosed foreign-WIP manifest never mentioned this path
+  // — an executor naming it anyway must not get away with claiming a block.
+  const job = { preRunDirtyPaths: ['src/a.ts'] };
+  const v = validateForeignWipBlockClaim(['src/a.ts', 'src/my-own-broken-file.ts'], job);
+  expect(v.ok).toBe(false);
+  expect(v.validPaths).toEqual(['src/a.ts']);
+  expect(v.invalidPaths).toEqual(['src/my-own-broken-file.ts']);
+});
+
+test('validateForeignWipBlockClaim: rejects a claim naming ONLY an unlisted path', () => {
+  const job = { preRunDirtyPaths: ['src/a.ts'] };
+  const v = validateForeignWipBlockClaim(['src/totally-unrelated.ts'], job);
+  expect(v.ok).toBe(false);
+  expect(v.invalidPaths).toEqual(['src/totally-unrelated.ts']);
+});
+
+test('validateForeignWipBlockClaim: rejects an empty claim (no evidence at all)', () => {
+  const job = { preRunDirtyPaths: ['src/a.ts'] };
+  expect(validateForeignWipBlockClaim([], job).ok).toBe(false);
+  expect(validateForeignWipBlockClaim(null, job).ok).toBe(false);
+});
+
+test('validateForeignWipBlockClaim: rejects against an empty/missing manifest', () => {
+  expect(validateForeignWipBlockClaim(['src/a.ts'], {}).ok).toBe(false);
+  expect(validateForeignWipBlockClaim(['src/a.ts'], null).ok).toBe(false);
+});
+
+// ─── requeueForeignWipBlockedJobs ──────────────────────────────────────────
+
+test('requeueForeignWipBlockedJobs: promotes skipped/blocked job to pending once its paths are clean', async () => {
+  const job = {
+    slug: '10-foo', status: 'skipped', cwd: '/repo', blockedByForeignWip: true,
+    foreignWipBlockedPaths: ['src/a.ts'], statusHistory: [],
+  };
+  await requeueForeignWipBlockedJobs([job], { getDirtyPaths: async () => [] });
+  expect(job.status).toBe('pending');
+  expect(job.blockedByForeignWip).toBeUndefined();
+  expect(job.foreignWipBlockedPaths).toBeUndefined();
+});
+
+test('requeueForeignWipBlockedJobs: leaves the job parked while any blocked path is still dirty', async () => {
+  const job = {
+    slug: '10-foo', status: 'skipped', cwd: '/repo', blockedByForeignWip: true,
+    foreignWipBlockedPaths: ['src/a.ts', 'src/b.ts'], statusHistory: [],
+  };
+  await requeueForeignWipBlockedJobs([job], { getDirtyPaths: async () => ['src/a.ts'] });
+  expect(job.status).toBe('skipped');
+  expect(job.blockedByForeignWip).toBe(true);
+});
+
+test('requeueForeignWipBlockedJobs: ignores jobs not in the blocked-skipped shape', async () => {
+  const skippedNotBlocked = { slug: '1', status: 'skipped', cwd: '/repo', statusHistory: [] };
+  const runningBlocked = { slug: '2', status: 'running', cwd: '/repo', blockedByForeignWip: true, foreignWipBlockedPaths: ['x'], statusHistory: [] };
+  const getDirtyPaths = async () => [];
+  await requeueForeignWipBlockedJobs([skippedNotBlocked, runningBlocked], { getDirtyPaths });
+  expect(skippedNotBlocked.status).toBe('skipped');
+  expect(runningBlocked.status).toBe('running');
+});
+
+test('requeueForeignWipBlockedJobs: leaves the row alone when the cwd is not a git repo (getDirtyPaths → null)', async () => {
+  const job = {
+    slug: '10-foo', status: 'skipped', cwd: '/not-a-repo', blockedByForeignWip: true,
+    foreignWipBlockedPaths: ['src/a.ts'], statusHistory: [],
+  };
+  await requeueForeignWipBlockedJobs([job], { getDirtyPaths: async () => null });
+  expect(job.status).toBe('skipped');
+});
+
+test('FOREIGN_WIP_BLOCK_STREAK_LIMIT is 3', () => {
+  expect(FOREIGN_WIP_BLOCK_STREAK_LIMIT).toBe(3);
+});

package/src/main/__tests__/scheduler-commit-guard-noop.test.cjs

@@ -24,6 +24,7 @@
 
 import { test, expect } from 'vitest';
 const { commitGuardVerdict } = require('../scheduler.cjs');
+const { resolveIsFixPlan } = require('../lib/fixPlanSlug.cjs');
 
 test('commitGuardVerdict: legitimate no-op verdict (pass_no_commit_already_shipped) + concurrent dirt → no flag (655 incident)', () => {
   const verifyResult = {
@@ -102,6 +103,25 @@ test('commitGuardVerdict: fix-plan job (523-fix-bounded-fix-plan-retry incident)
   expect(verdict).toBeNull();
 });
 
+test('commitGuardVerdict: a zero-edit run of a human-authored PRD whose slug merely starts with "fix-" still yields silent_no_op (PRD 1131 — not exempted by name alone)', () => {
+  // Mirrors PRD 1126: authored via scheduler_create_prd (isFixPlan stamped
+  // false at reconcile time), slug happens to read "fix-...". Feeding the
+  // job's own persisted isFixPlan through resolveIsFixPlan (the same call
+  // spawnJob makes) must NOT exempt this zero-edit run from the guard.
+  const job = { slug: '126-fix-plan-death-reopens-parent', isFixPlan: false };
+  const verdict = commitGuardVerdict({
+    newlyDirty: [],
+    siblingRunning: false,
+    jobSelfCommitted: false,
+    legitimateNoOp: false,
+    isFixPlanJob: resolveIsFixPlan(job.slug, job.isFixPlan),
+    verifyResult: null,
+  });
+  expect(verdict).not.toBeNull();
+  expect(verdict.verdict).toBe('silent_no_op');
+  expect(verdict.downgradeTo).toBe('needs_review');
+});
+
 test('commitGuardVerdict: fix-plan job that DID leave real dirt behind is still flagged (isFixPlanJob only exempts the zero-edit case)', () => {
   const verdict = commitGuardVerdict({
     newlyDirty: ['src/main/someFeature.cjs'],

package/src/main/__tests__/scheduler-finalize-dispatch-guards.test.cjs

@@ -0,0 +1,229 @@
+/**
+ * scheduler-finalize-dispatch-guards.test.cjs — regression cover for the
+ * 2026-09-06 incident: PRD 1133 (reaper integration check) shipped correctly
+ * in commit 5de4134, but its finalize mutate's silent early-return dropped
+ * three subsequent no-op re-verifications of the same already-shipped slug
+ * with no audit trail, leaving the row stuck 'pending' forever and causing
+ * the dispatcher to re-fire it three more times.
+ *
+ * Covers the three pure decision helpers extracted for this fix:
+ *  - evaluateFinalizeDrop: never silently discard a finalize (row missing,
+ *    or row moved off 'running' by a concurrent cancel) — always says so,
+ *    and still lets a genuinely-landed commit be stamped as a durable fact.
+ *  - evaluateDispatchSidecarReconcile: refuse to re-dispatch a pending row
+ *    whose newest run sidecar already shows a completed-equivalent outcome
+ *    for THIS queueing episode.
+ *  - isQueueRowRegression: detect (never repair) a running->pending change
+ *    whose statusHistory got shorter — evidence of lost state, not a real
+ *    transition.
+ *
+ * HOME is overridden to a tmp dir BEFORE requiring scheduler.cjs, matching
+ * scheduler-reap-dead-running-jobs.test.cjs's pattern — every path this
+ * module touches is baked into a top-level const from os.homedir() at
+ * require time.
+ *
+ * Run: timeout 120 npx vitest run src/main/__tests__/scheduler-finalize-dispatch-guards.test.cjs
+ */
+
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const tmpHome = fs.mkdtempSync(path.join(os.tmpdir(), 'scheduler-finalize-dispatch-guards-test-'));
+process.env.HOME = tmpHome;
+
+const {
+  evaluateFinalizeDrop,
+  evaluateDispatchSidecarReconcile,
+  isQueueRowRegression,
+} = require('../scheduler.cjs');
+
+describe('evaluateFinalizeDrop', () => {
+  it('drops loudly (row-missing) with nothing to stamp when the row vanished from s.jobs', () => {
+    const decision = evaluateFinalizeDrop({
+      rowExists: false,
+      rowStatus: null,
+      rowRunId: null,
+      rowLandedCommit: null,
+      runId: 'run-2',
+      landedCommit: 'deadbeef',
+    });
+    assert.equal(decision.drop, true);
+    assert.equal(decision.reason, 'row-missing');
+    assert.equal(decision.stampLandedCommit, null);
+  });
+
+  it('drops the status change (row-not-running) but stamps landedCommit when this run owns the row', () => {
+    const decision = evaluateFinalizeDrop({
+      rowExists: true,
+      rowStatus: 'failed', // e.g. remote.cancelJob already finalized it (PRD 1024)
+      rowRunId: 'run-2',
+      rowLandedCommit: null,
+      runId: 'run-2',
+      landedCommit: 'deadbeef',
+    });
+    assert.equal(decision.drop, true);
+    assert.equal(decision.reason, 'row-not-running');
+    assert.equal(decision.stampLandedCommit, 'deadbeef');
+  });
+
+  it('stamps landedCommit even when the row carries a different runId, as long as it has none of its own', () => {
+    const decision = evaluateFinalizeDrop({
+      rowExists: true,
+      rowStatus: 'pending',
+      rowRunId: 'some-other-run',
+      rowLandedCommit: null,
+      runId: 'run-2',
+      landedCommit: 'deadbeef',
+    });
+    assert.equal(decision.drop, true);
+    assert.equal(decision.stampLandedCommit, 'deadbeef');
+  });
+
+  it('never overwrites a row that already carries its own newer landedCommit from a different run', () => {
+    const decision = evaluateFinalizeDrop({
+      rowExists: true,
+      rowStatus: 'failed',
+      rowRunId: 'some-other-run',
+      rowLandedCommit: 'already-there',
+      runId: 'run-2',
+      landedCommit: 'deadbeef',
+    });
+    assert.equal(decision.drop, true);
+    assert.equal(decision.stampLandedCommit, null);
+  });
+
+  it('never re-legalizes a cancelled (failed) row back to completed — the PRD-1024 protection', () => {
+    // The finalize call site never even reaches transitionJob for a dropped
+    // finalize; this test documents the contract evaluateFinalizeDrop enforces:
+    // drop:true means the caller MUST NOT change job.status.
+    const decision = evaluateFinalizeDrop({
+      rowExists: true,
+      rowStatus: 'failed',
+      rowRunId: 'run-2',
+      rowLandedCommit: null,
+      runId: 'run-2',
+      landedCommit: 'deadbeef',
+    });
+    assert.equal(decision.drop, true);
+  });
+
+  it('does not drop when the row is still running — the normal finalize path', () => {
+    const decision = evaluateFinalizeDrop({
+      rowExists: true,
+      rowStatus: 'running',
+      rowRunId: 'run-2',
+      rowLandedCommit: null,
+      runId: 'run-2',
+      landedCommit: 'deadbeef',
+    });
+    assert.equal(decision.drop, false);
+    assert.equal(decision.stampLandedCommit, null);
+  });
+});
+
+describe('evaluateDispatchSidecarReconcile', () => {
+  const baseRow = {
+    rowStatus: 'pending',
+    rowRunId: null,
+    statusHistory: [
+      { from: 'running', to: 'pending', at: '2026-09-06T19:30:00.000Z' },
+    ],
+    queuedAt: '2026-09-06T17:02:07.815Z',
+  };
+
+  it('skips dispatch when a prior run of this slug already completed after the last pending transition', () => {
+    const decision = evaluateDispatchSidecarReconcile({
+      ...baseRow,
+      outcome: { status: 'completed', runId: '2026-09-06T19-26-54-681Z', finishedAt: '2026-09-06T19:35:00.000Z' },
+    });
+    assert.equal(decision.skip, true);
+    assert.equal(decision.runId, '2026-09-06T19-26-54-681Z');
+  });
+
+  it('proceeds with dispatch when a deliberate human re-queue postdates the earlier completion', () => {
+    // The re-queue's own pending transition (19:30) is AFTER the completed
+    // sidecar's finishedAt (18:00) — an OLDER episode's completion, not this one.
+    const decision = evaluateDispatchSidecarReconcile({
+      ...baseRow,
+      outcome: { status: 'completed', runId: 'old-run', finishedAt: '2026-09-06T18:00:00.000Z' },
+    });
+    assert.equal(decision.skip, false);
+  });
+
+  it('proceeds with dispatch when there is no sidecar at all (guard is a no-op)', () => {
+    const decision = evaluateDispatchSidecarReconcile({ ...baseRow, outcome: null });
+    assert.equal(decision.skip, false);
+  });
+
+  it('proceeds with dispatch when the sidecar belongs to this row\'s own current runId', () => {
+    const decision = evaluateDispatchSidecarReconcile({
+      ...baseRow,
+      rowRunId: 'run-x',
+      outcome: { status: 'completed', runId: 'run-x', finishedAt: '2026-09-06T19:35:00.000Z' },
+    });
+    assert.equal(decision.skip, false);
+  });
+
+  it('proceeds with dispatch when the row is not pending (e.g. needs_review resume-recovery)', () => {
+    const decision = evaluateDispatchSidecarReconcile({
+      ...baseRow,
+      rowStatus: 'needs_review',
+      outcome: { status: 'completed', runId: 'some-run', finishedAt: '2026-09-06T19:35:00.000Z' },
+    });
+    assert.equal(decision.skip, false);
+  });
+
+  it('proceeds with dispatch when the newest sidecar reports a failed (not completed-equivalent) outcome', () => {
+    const decision = evaluateDispatchSidecarReconcile({
+      ...baseRow,
+      outcome: { status: 'failed', runId: 'some-run', finishedAt: '2026-09-06T19:35:00.000Z' },
+    });
+    assert.equal(decision.skip, false);
+  });
+
+  it('falls back to queuedAt when the row has never been reset (no pending statusHistory entry)', () => {
+    const decision = evaluateDispatchSidecarReconcile({
+      rowStatus: 'pending',
+      rowRunId: null,
+      statusHistory: [],
+      queuedAt: '2026-09-06T17:02:07.815Z',
+      outcome: { status: 'completed', runId: 'some-run', finishedAt: '2026-09-06T19:35:00.000Z' },
+    });
+    assert.equal(decision.skip, true);
+  });
+});
+
+describe('isQueueRowRegression', () => {
+  it('flags a running->pending change whose statusHistory got shorter', () => {
+    assert.equal(
+      isQueueRowRegression({ statusBefore: 'running', statusAfter: 'pending', historyLenBefore: 5, historyLenAfter: 3 }),
+      true,
+    );
+  });
+
+  it('does not flag a running->pending change with a normal appended (equal or longer) history', () => {
+    assert.equal(
+      isQueueRowRegression({ statusBefore: 'running', statusAfter: 'pending', historyLenBefore: 5, historyLenAfter: 6 }),
+      false,
+    );
+    assert.equal(
+      isQueueRowRegression({ statusBefore: 'running', statusAfter: 'pending', historyLenBefore: 20, historyLenAfter: 20 }),
+      false,
+    );
+  });
+
+  it('does not flag a shortened history on transitions other than running->pending', () => {
+    assert.equal(
+      isQueueRowRegression({ statusBefore: 'pending', statusAfter: 'completed', historyLenBefore: 5, historyLenAfter: 3 }),
+      false,
+    );
+    assert.equal(
+      isQueueRowRegression({ statusBefore: 'running', statusAfter: 'completed', historyLenBefore: 5, historyLenAfter: 3 }),
+      false,
+    );
+  });
+});