@warpgogol/forge 5.2.0 → 5.2.4

package/os/compass/handlers/compass-audit-handler.ts

@@ -13,12 +13,14 @@ mode (RFC-0556). Drives per-file semantic-truth auditing on a revision cadence (
   <item>RFC-0352: initial implementation of compass.audit.plan, compass.audit.record, compass.audit.baseline, compass.audit.validate.</item>
   <item>RFC-0556: moved from @warpgogol/site-kernel-checks to @warpgogol/forge for autonomous mode.</item>
   <item>RFC-1094: audit work orders now carry the KEY_DECISIONS block alongside MODULE_CONTRACT and CHANGE_SUMMARY.</item>
+  <item>RFC-1139: CLI hint accuracy and agent-safety hygiene — rfc.create hint, EC-14-PARTIAL, amend delegation, ledger scope, sync footer, mission.open remnants</item>
+  <item>RFC-1143: validate/plan/record apply filterLedgerEligiblePaths — ledger-ineligible authored paths (missions/, gitignored) are skipped with skippedIneligible diagnostics instead of failing COMPASS-AUDIT-01; record warns but still writes.</item>
 </CHANGE_SUMMARY>
 */
 
-import { readFile } from "node:fs/promises";
+import { mkdir, readFile } from "node:fs/promises";
 import { resolve, relative } from "node:path";
-import { execFile } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import { promisify } from "node:util";
 import { createCompassInventoryEntries } from "./compass-inventory.ts";
 import { resolveCompassPolicy } from "../policy.ts";
@@ -37,6 +39,9 @@ import { parse as yamlParse, stringify as yamlStringify } from "yaml";
 const execFileAsync = promisify(execFile);
 const LEDGER_PATH = "docs/compass-audit-ledger.generated.yaml";
 const DEFAULT_THRESHOLD = 30;
+// RFC-1143: cap the skippedPaths diagnostic list so huge ineligible sets do not
+// flood the output; the pretty summary appends "and N more" when truncated.
+const SKIPPED_PATHS_CAP = 20;
 
 function resolveRevisionThreshold(value: unknown, fallback: number): number {
   if (value === undefined) return fallback;
@@ -99,6 +104,7 @@ async function saveLedger(workspaceRoot: string, ledger: CompassAuditLedger): Pr
   const normalized = withLedgerAdvisory(ledger);
   normalized.entries.sort((a, b) => a.path.localeCompare(b.path));
   const abs = resolve(workspaceRoot, LEDGER_PATH);
+  await mkdir(resolve(abs, ".."), { recursive: true });
   const header = buildGeneratedHeader({
     ownerCommand: "compass.audit.record",
     filePath: LEDGER_PATH,
@@ -129,6 +135,54 @@ function getAuthoredEntries(entries: CompassInventoryEntry[]): CompassInventoryE
   );
 }
 
+// RFC-1139: the tracked ledger must not accumulate entries for paths that
+// can never be audited long-term — gitignored roots (missions/, dist/) and
+// the missions/ tree specifically (workpieces move to archive on close).
+// Batch-checks `git check-ignore --stdin` once for all candidate paths.
+async function filterLedgerEligiblePaths(
+  workspaceRoot: string,
+  paths: string[],
+): Promise<Set<string>> {
+  const eligible = new Set<string>();
+  const candidates = paths.filter((p) => !p.startsWith("missions/"));
+  let ignored = new Set<string>();
+  if (candidates.length > 0) {
+    try {
+      const stdout = execFileSync("git", ["check-ignore", "--stdin"], {
+        cwd: workspaceRoot,
+        input: candidates.join("\n"),
+        encoding: "utf-8",
+      });
+      ignored = new Set(stdout.split("\n").filter((l: string) => l.length > 0));
+    } catch {
+      // check-ignore exits 1 when nothing is ignored — treat all as eligible
+      ignored = new Set();
+    }
+  }
+  for (const p of candidates) {
+    if (!ignored.has(p)) eligible.add(p);
+  }
+  return eligible;
+}
+
+// RFC-1143: partition authored entries into ledger-eligible and ineligible
+// sets. Shared by plan/validate so the predicate lives in exactly one place.
+async function partitionLedgerEligibleAuthored(
+  workspaceRoot: string,
+  authored: CompassInventoryEntry[],
+): Promise<{ eligible: CompassInventoryEntry[]; ineligible: CompassInventoryEntry[] }> {
+  const eligiblePaths = await filterLedgerEligiblePaths(
+    workspaceRoot,
+    authored.map((e) => e.path),
+  );
+  const eligible: CompassInventoryEntry[] = [];
+  const ineligible: CompassInventoryEntry[] = [];
+  for (const entry of authored) {
+    (eligiblePaths.has(entry.path) ? eligible : ineligible).push(entry);
+  }
+  return { eligible, ineligible };
+}
+
 export async function runCompassAuditPlan(
   input: ForgeCommandInput,
   context: ForgeRuntimeContext,
@@ -137,6 +191,7 @@ export async function runCompassAuditPlan(
     threshold: number;
     dueCount: number;
     items: CompassAuditWorkOrderItem[];
+    skippedIneligible: number;
   }>
 > {
   const scanRoot = resolveCompassScanRoot(input, context);
@@ -153,6 +208,15 @@ export async function runCompassAuditPlan(
 
   const threshold = resolveRevisionThreshold(input.flags["threshold"], ledger.revisionThreshold);
 
+  // RFC-1143: drop ledger-ineligible authored paths (missions/, gitignored)
+  // before the per-entry revision loop — they can never be audited long-term
+  // and must not cost a git call each.
+  const { eligible: eligibleAuthored, ineligible } = await partitionLedgerEligibleAuthored(
+    context.workspaceRoot,
+    authored,
+  );
+  const skippedIneligible = ineligible.length;
+
   const ledgerMap = new Map<string, CompassAuditLedgerEntry>();
   for (const e of ledger.entries) {
     ledgerMap.set(e.path, e);
@@ -160,7 +224,7 @@ export async function runCompassAuditPlan(
 
   const items: CompassAuditWorkOrderItem[] = [];
 
-  for (const entry of authored) {
+  for (const entry of eligibleAuthored) {
     const ledgerEntry = ledgerMap.get(entry.path);
     const auditedRevision = ledgerEntry?.auditedRevision ?? null;
 
@@ -192,10 +256,12 @@ export async function runCompassAuditPlan(
 
   items.sort((a, b) => a.path.localeCompare(b.path));
 
-  context.logger.info(`[compass.audit.plan] threshold=${threshold}, due=${items.length}`);
+  context.logger.info(
+    `[compass.audit.plan] threshold=${threshold}, due=${items.length}, skippedIneligible=${skippedIneligible}`,
+  );
 
   return {
-    data: { threshold, dueCount: items.length, items },
+    data: { threshold, dueCount: items.length, items, skippedIneligible },
     exitCode: 0,
     summary: `[compass.audit.plan] ${items.length} files due for audit (threshold=${threshold})`,
     nextSteps:
@@ -235,6 +301,16 @@ export async function runCompassAuditRecord(
 
   const filePath = relative(context.workspaceRoot, resolve(process.cwd(), rawFilePath));
 
+  // RFC-1143: warn when recording an audit for a ledger-ineligible path — the
+  // entry will be swept by the next baseline run (RFC-1139). Operator intent
+  // wins: the write still proceeds.
+  const recordEligible = await filterLedgerEligiblePaths(context.workspaceRoot, [filePath]);
+  if (!recordEligible.has(filePath)) {
+    context.logger.warn(
+      `[compass.audit.record] ${filePath}: path is ledger-ineligible (missions/ or gitignored) — this entry will be swept by the next compass.audit.baseline run`,
+    );
+  }
+
   const { revision, entityId, contentHash } = await getRevisionByPath(
     context.workspaceRoot,
     filePath,
@@ -302,11 +378,17 @@ export async function runCompassAuditBaseline(
   const authored = getAuthoredEntries(entries);
   const ledger = await loadLedger(context.workspaceRoot);
 
+  // RFC-1139: drop ineligible entries (missions/, gitignored) already in the
+  // ledger — self-healing cleanup — and never seed new ones.
+  const candidatePaths = [...authored.map((e) => e.path), ...ledger.entries.map((e) => e.path)];
+  const eligible = await filterLedgerEligiblePaths(context.workspaceRoot, candidatePaths);
+  ledger.entries = ledger.entries.filter((e) => eligible.has(e.path));
+
   const existingPaths = new Set(ledger.entries.map((e) => e.path));
   let seededCount = 0;
 
   for (const entry of authored) {
-    if (existingPaths.has(entry.path)) {
+    if (!eligible.has(entry.path) || existingPaths.has(entry.path)) {
       continue;
     }
 
@@ -358,6 +440,8 @@ export async function runCompassAuditValidate(
       message: string;
       fix: string;
     }>;
+    skippedIneligible: number;
+    skippedPaths: string[];
   }>
 > {
   const strict = input.flags["strict"] === true;
@@ -373,6 +457,16 @@ export async function runCompassAuditValidate(
   const authored = getAuthoredEntries(entries);
   const ledger = await loadLedger(context.workspaceRoot);
 
+  // RFC-1143: drop ledger-ineligible authored paths (missions/, gitignored)
+  // before the per-entry revision loop — baseline is forbidden to seed them,
+  // so demanding entries is a guaranteed false-positive (COMPASS-AUDIT-01).
+  const { eligible: eligibleAuthored, ineligible } = await partitionLedgerEligibleAuthored(
+    context.workspaceRoot,
+    authored,
+  );
+  const skippedPaths = ineligible.map((e) => e.path).sort();
+  const skippedIneligible = skippedPaths.length;
+
   const ledgerMap = new Map<string, CompassAuditLedgerEntry>();
   for (const e of ledger.entries) {
     ledgerMap.set(e.path, e);
@@ -386,7 +480,7 @@ export async function runCompassAuditValidate(
     fix: string;
   }> = [];
 
-  for (const entry of authored) {
+  for (const entry of eligibleAuthored) {
     const ledgerEntry = ledgerMap.get(entry.path);
     const auditedRevision = ledgerEntry?.auditedRevision ?? null;
 
@@ -415,8 +509,22 @@ export async function runCompassAuditValidate(
   const dueCount = diagnostics.length;
   const hasErrors = strict && dueCount > 0;
 
+  if (skippedIneligible > 0) {
+    const shown = skippedPaths.slice(0, SKIPPED_PATHS_CAP);
+    const more = skippedIneligible - shown.length;
+    context.logger.info(
+      `[compass.audit.validate] skipped ${skippedIneligible} ledger-ineligible path(s) (missions/, gitignored)${more > 0 ? ` and ${more} more` : ""}`,
+    );
+  }
+
   return {
-    data: { strict, dueCount, diagnostics },
+    data: {
+      strict,
+      dueCount,
+      diagnostics,
+      skippedIneligible,
+      skippedPaths: skippedPaths.slice(0, SKIPPED_PATHS_CAP),
+    },
     exitCode: hasErrors ? 1 : 0,
     summary: dueCount > 0 ? undefined : `[compass.audit.validate] OK (0 files overdue)`,
     nextSteps:

package/os/compass/handlers/tests/compass-audit-plan.test.ts

@@ -0,0 +1,98 @@
+/*
+<MODULE_CONTRACT>
+  <purpose>
+    RFC-1143 AC-4: compass.audit.plan must not list ledger-ineligible paths
+    (missions/, gitignored) in its due work-order items and must report the
+    skippedIneligible count.
+  </purpose>
+</MODULE_CONTRACT>
+*/
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { runCompassAuditPlan } from "../compass-audit-handler.ts";
+import type { ForgeCommandInput, ForgeRuntimeContext } from "../../../../src/types.ts";
+
+const execFileAsync = promisify(execFile);
+
+const logger = {
+  section() {},
+  info() {},
+  warn() {},
+  error() {},
+  success() {},
+  getEvents() {
+    return [];
+  },
+};
+
+function makeContext(workspaceRoot: string): ForgeRuntimeContext {
+  return {
+    workspaceRoot,
+    site: undefined,
+    siteExplicit: false,
+    logger: logger as never,
+    dryRun: false,
+    outputFormat: "json",
+    io: {} as never,
+    actualState: undefined as never,
+    fileIntents: [],
+  } as unknown as ForgeRuntimeContext;
+}
+
+// missions/ is not in the default scanRoots — pass both roots so the fixture
+// produces a mixed eligible/ineligible authored set.
+const SCAN_ROOTS = ["missions", "packages"];
+
+function makeInput(flags: Record<string, unknown> = {}): ForgeCommandInput {
+  return { argv: [], flags: { root: SCAN_ROOTS, ...flags } } as unknown as ForgeCommandInput;
+}
+
+const ELIGIBLE_FILE = "packages/foo/index.ts";
+
+describe("compass.audit.plan — RFC-1143 ledger-ineligible skips", () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), "compass-plan-"));
+    await mkdir(join(root, "packages", "foo"), { recursive: true });
+    await writeFile(join(root, "packages", "foo", "index.ts"), "export const x = 1;\n", "utf8");
+    await mkdir(join(root, "missions", "acme-m000001", "workpiece", "src"), {
+      recursive: true,
+    });
+    await writeFile(
+      join(root, "missions", "acme-m000001", "workpiece", "src", "local.ts"),
+      "export const y = 2;\n",
+      "utf8",
+    );
+    await writeFile(join(root, ".gitignore"), "missions/\n", "utf8");
+    await execFileAsync("git", ["init"], { cwd: root });
+    await execFileAsync("git", ["config", "user.email", "test@test.com"], { cwd: root });
+    await execFileAsync("git", ["config", "user.name", "Test"], { cwd: root });
+    await execFileAsync("git", ["add", "."], { cwd: root });
+    await execFileAsync("git", ["commit", "-m", "init"], { cwd: root });
+  });
+
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it("AC-4: due items exclude ledger-ineligible paths and report skippedIneligible", async () => {
+    const result = await runCompassAuditPlan(makeInput(), makeContext(root));
+    expect(result.exitCode).toBe(0);
+    const data = result.data as {
+      items: Array<{ path: string }>;
+      skippedIneligible: number;
+    };
+    expect(
+      data.items.some((i) => i.path.startsWith("missions/")),
+      "plan must not emit work orders for ledger-ineligible paths — check the eligibility partition in runCompassAuditPlan",
+    ).toBe(false);
+    expect(data.items.some((i) => i.path === ELIGIBLE_FILE)).toBe(true);
+    expect(data.skippedIneligible).toBeGreaterThan(0);
+  });
+});

package/os/compass/handlers/tests/compass-audit-record.test.ts

@@ -0,0 +1,105 @@
+/*
+<MODULE_CONTRACT>
+  <purpose>
+    RFC-1143 AC-5: compass.audit.record on a ledger-ineligible path (missions/,
+    gitignored) still writes the entry (operator intent wins) but emits a
+    warning that the next baseline run will sweep it.
+  </purpose>
+</MODULE_CONTRACT>
+*/
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, mkdir, writeFile, rm, readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { parse as yamlParse } from "yaml";
+import { runCompassAuditRecord } from "../compass-audit-handler.ts";
+import type { ForgeCommandInput, ForgeRuntimeContext } from "../../../../src/types.ts";
+
+const execFileAsync = promisify(execFile);
+
+const warnings: string[] = [];
+const logger = {
+  section() {},
+  info() {},
+  warn(msg: string) {
+    warnings.push(msg);
+  },
+  error() {},
+  success() {},
+  getEvents() {
+    return [];
+  },
+};
+
+function makeContext(workspaceRoot: string): ForgeRuntimeContext {
+  return {
+    workspaceRoot,
+    site: undefined,
+    siteExplicit: false,
+    logger: logger as never,
+    dryRun: false,
+    outputFormat: "json",
+    io: {} as never,
+    actualState: undefined as never,
+    fileIntents: [],
+  } as unknown as ForgeRuntimeContext;
+}
+
+function makeInput(flags: Record<string, unknown> = {}): ForgeCommandInput {
+  return { argv: [], flags } as unknown as ForgeCommandInput;
+}
+
+const MISSION_FILE = "missions/acme-m000001/workpiece/src/local.ts";
+
+describe("compass.audit.record — RFC-1143 ineligible-path warning", () => {
+  let root: string;
+
+  beforeEach(async () => {
+    warnings.length = 0;
+    root = await mkdtemp(join(tmpdir(), "compass-record-"));
+    await mkdir(join(root, "missions", "acme-m000001", "workpiece", "src"), {
+      recursive: true,
+    });
+    await writeFile(
+      join(root, "missions", "acme-m000001", "workpiece", "src", "local.ts"),
+      "export const y = 2;\n",
+      "utf8",
+    );
+    await writeFile(join(root, ".gitignore"), "missions/\n", "utf8");
+    await execFileAsync("git", ["init"], { cwd: root });
+    await execFileAsync("git", ["config", "user.email", "test@test.com"], { cwd: root });
+    await execFileAsync("git", ["config", "user.name", "Test"], { cwd: root });
+    await execFileAsync("git", ["add", "."], { cwd: root });
+    await execFileAsync("git", ["commit", "-m", "init"], { cwd: root });
+  });
+
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it("AC-5: record on ineligible path writes the entry and warns about the sweep", async () => {
+    const absTarget = join(root, MISSION_FILE);
+    const result = await runCompassAuditRecord(
+      makeInput({ file: absTarget, verdict: "pass", agent: "agent:test" }),
+      makeContext(root),
+    );
+    expect(result.exitCode).toBe(0);
+
+    // Entry was written despite ineligibility (operator intent wins)
+    const ledgerRaw = await readFile(
+      join(root, "docs", "compass-audit-ledger.generated.yaml"),
+      "utf8",
+    );
+    const ledger = yamlParse(ledgerRaw) as { entries: Array<{ path: string }> };
+    expect(ledger.entries.some((e) => e.path === MISSION_FILE)).toBe(true);
+
+    // Warning about the next baseline sweep was emitted
+    expect(
+      warnings.some((w) => w.includes("ledger-ineligible") && w.includes("baseline")),
+      "record must warn that an ineligible entry will be swept by the next baseline run",
+    ).toBe(true);
+  });
+});

package/os/compass/handlers/tests/compass-audit-validate.test.ts

@@ -0,0 +1,133 @@
+/*
+<MODULE_CONTRACT>
+  <purpose>
+    RFC-1143 AC-1..AC-3: compass.audit.validate must skip ledger-ineligible
+    authored paths (missions/, gitignored) instead of emitting COMPASS-AUDIT-01,
+    report skippedIneligible/skippedPaths diagnostics, and still flag eligible
+    authored files that have no ledger entry.
+  </purpose>
+</MODULE_CONTRACT>
+*/
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, mkdir, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { runCompassAuditValidate } from "../compass-audit-handler.ts";
+import type { ForgeCommandInput, ForgeRuntimeContext } from "../../../../src/types.ts";
+
+const execFileAsync = promisify(execFile);
+
+const logger = {
+  section() {},
+  info() {},
+  warn() {},
+  error() {},
+  success() {},
+  getEvents() {
+    return [];
+  },
+};
+
+function makeContext(workspaceRoot: string): ForgeRuntimeContext {
+  return {
+    workspaceRoot,
+    site: undefined,
+    siteExplicit: false,
+    logger: logger as never,
+    dryRun: false,
+    outputFormat: "json",
+    io: {} as never,
+    actualState: undefined as never,
+    fileIntents: [],
+  } as unknown as ForgeRuntimeContext;
+}
+
+// missions/ is not in the default scanRoots — the real-world failure mode is a
+// scoped scan (--root / site workpiece) that surfaces missions/ paths. Passing
+// both roots reproduces the mixed eligible/ineligible authored set.
+const SCAN_ROOTS = ["missions", "packages"];
+
+function makeInput(flags: Record<string, unknown> = {}): ForgeCommandInput {
+  return { argv: [], flags: { root: SCAN_ROOTS, ...flags } } as unknown as ForgeCommandInput;
+}
+
+const MISSION_FILE = "missions/acme-m000001/workpiece/src/local.ts";
+const ELIGIBLE_FILE = "packages/foo/index.ts";
+
+describe("compass.audit.validate — RFC-1143 ledger-ineligible skips", () => {
+  let root: string;
+
+  beforeEach(async () => {
+    root = await mkdtemp(join(tmpdir(), "compass-validate-"));
+    // Authored source file (plain .ts, no generated marker → authored entry)
+    await mkdir(join(root, "packages", "foo"), { recursive: true });
+    await writeFile(join(root, "packages", "foo", "index.ts"), "export const x = 1;\n", "utf8");
+    // Mission workpiece file — authored but ledger-ineligible
+    await mkdir(join(root, "missions", "acme-m000001", "workpiece", "src"), {
+      recursive: true,
+    });
+    await writeFile(
+      join(root, "missions", "acme-m000001", "workpiece", "src", "local.ts"),
+      "export const y = 2;\n",
+      "utf8",
+    );
+    await writeFile(join(root, ".gitignore"), "missions/\n", "utf8");
+    // Git repo for getRevisionByPath + check-ignore
+    await execFileAsync("git", ["init"], { cwd: root });
+    await execFileAsync("git", ["config", "user.email", "test@test.com"], { cwd: root });
+    await execFileAsync("git", ["config", "user.name", "Test"], { cwd: root });
+    await execFileAsync("git", ["add", "."], { cwd: root });
+    await execFileAsync("git", ["commit", "-m", "init"], { cwd: root });
+  });
+
+  afterEach(async () => {
+    await rm(root, { recursive: true, force: true });
+  });
+
+  it("AC-1: no COMPASS-AUDIT-01 diagnostic for missions/ paths", async () => {
+    const result = await runCompassAuditValidate(makeInput(), makeContext(root));
+    const diagnostics = (result.data as { diagnostics: Array<{ file: string; ruleId: string }> })
+      .diagnostics;
+    expect(
+      diagnostics.some((d) => d.file.startsWith("missions/")),
+      "validate must not flag ledger-ineligible missions/ paths — check the eligibility partition in runCompassAuditValidate",
+    ).toBe(false);
+  });
+
+  it("AC-2: result reports skippedIneligible > 0 and skippedPaths", async () => {
+    const result = await runCompassAuditValidate(makeInput(), makeContext(root));
+    const data = result.data as { skippedIneligible: number; skippedPaths: string[] };
+    expect(data.skippedIneligible).toBeGreaterThan(0);
+    expect(data.skippedPaths).toContain(MISSION_FILE);
+  });
+
+  it("AC-3: eligible authored file without ledger entry still emits COMPASS-AUDIT-01", async () => {
+    const result = await runCompassAuditValidate(makeInput(), makeContext(root));
+    const diagnostics = (result.data as { diagnostics: Array<{ file: string; ruleId: string }> })
+      .diagnostics;
+    expect(
+      diagnostics.some((d) => d.file === ELIGIBLE_FILE && d.ruleId === "COMPASS-AUDIT-01"),
+      "eligible authored files must still be audited — check that only ineligible paths were partitioned out",
+    ).toBe(true);
+  });
+
+  it("AC-1 (strict): exits 0 when only ineligible paths would be due", async () => {
+    // Seed a ledger entry for the eligible file at its current revision (1
+    // commit → revision 1) so only the missions/ file would be due.
+    await mkdir(join(root, "docs"), { recursive: true });
+    await writeFile(
+      join(root, "docs", "compass-audit-ledger.generated.yaml"),
+      `entries:\n  - path: ${ELIGIBLE_FILE}\n    entityId: ""\n    auditedRevision: 1\n    auditedHash: ""\n    auditedAt: "2026-01-01T00:00:00Z"\n    verdict: pass\n    agent: human:test\n`,
+      "utf8",
+    );
+
+    const result = await runCompassAuditValidate(makeInput({ strict: true }), makeContext(root));
+    expect(result.exitCode).toBe(0);
+    const data = result.data as { dueCount: number; skippedIneligible: number };
+    expect(data.dueCount).toBe(0);
+    expect(data.skippedIneligible).toBeGreaterThan(0);
+  });
+});